diff --git a/boost/bind/bind.hpp b/boost/bind/bind.hpp
index 85d675a..1ccbc73 100644
--- a/boost/bind/bind.hpp
+++ b/boost/bind/bind.hpp
@@ -2122,21 +2122,31 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_CC
 #define BOOST_BIND_ST
+#define BOOST_BIND_NOEXCEPT
 
 #include <boost/bind/bind_cc.hpp>
 
+# ifdef __cpp_noexcept_function_type
+#   undef BOOST_BIND_NOEXCEPT
+#   define BOOST_BIND_NOEXCEPT noexcept
+#   include <boost/bind/bind_cc.hpp>
+# endif
+
 #undef BOOST_BIND_CC
 #undef BOOST_BIND_ST
+#undef BOOST_BIND_NOEXCEPT
 
 #ifdef BOOST_BIND_ENABLE_STDCALL
 
 #define BOOST_BIND_CC __stdcall
 #define BOOST_BIND_ST
+#define BOOST_BIND_NOEXCEPT
 
 #include <boost/bind/bind_cc.hpp>
 
 #undef BOOST_BIND_CC
 #undef BOOST_BIND_ST
+#undef BOOST_BIND_NOEXCEPT
 
 #endif
 
@@ -2144,11 +2154,13 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_CC __fastcall
 #define BOOST_BIND_ST
+#define BOOST_BIND_NOEXCEPT
 
 #include <boost/bind/bind_cc.hpp>
 
 #undef BOOST_BIND_CC
 #undef BOOST_BIND_ST
+#undef BOOST_BIND_NOEXCEPT
 
 #endif
 
@@ -2156,11 +2168,13 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_ST pascal
 #define BOOST_BIND_CC
+#define BOOST_BIND_NOEXCEPT
 
 #include <boost/bind/bind_cc.hpp>
 
 #undef BOOST_BIND_ST
 #undef BOOST_BIND_CC
+#undef BOOST_BIND_NOEXCEPT
 
 #endif
 
@@ -2168,23 +2182,33 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_MF_NAME(X) X
 #define BOOST_BIND_MF_CC
+#define BOOST_BIND_MF_NOEXCEPT
 
 #include <boost/bind/bind_mf_cc.hpp>
 #include <boost/bind/bind_mf2_cc.hpp>
 
+# ifdef __cpp_noexcept_function_type
+#   undef BOOST_BIND_MF_NOEXCEPT
+#   define BOOST_BIND_MF_NOEXCEPT noexcept
+#   include <boost/bind/bind_mf_cc.hpp>
+# endif
+
 #undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
+#undef BOOST_BIND_MF_NOEXCEPT
 
 #ifdef BOOST_MEM_FN_ENABLE_CDECL
 
 #define BOOST_BIND_MF_NAME(X) X##_cdecl
 #define BOOST_BIND_MF_CC __cdecl
+#define BOOST_BIND_MF_NOEXCEPT
 
 #include <boost/bind/bind_mf_cc.hpp>
 #include <boost/bind/bind_mf2_cc.hpp>
 
 #undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
+#undef BOOST_BIND_MF_NOEXCEPT
 
 #endif
 
@@ -2192,12 +2216,14 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_MF_NAME(X) X##_stdcall
 #define BOOST_BIND_MF_CC __stdcall
+#define BOOST_BIND_MF_NOEXCEPT
 
 #include <boost/bind/bind_mf_cc.hpp>
 #include <boost/bind/bind_mf2_cc.hpp>
 
 #undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
+#undef BOOST_BIND_MF_NOEXCEPT
 
 #endif
 
@@ -2205,12 +2231,14 @@ template<class F, class A1, class A2, class A3, class A4, class A5, class A6, cl
 
 #define BOOST_BIND_MF_NAME(X) X##_fastcall
 #define BOOST_BIND_MF_CC __fastcall
+#define BOOST_BIND_MF_NOEXCEPT
 
 #include <boost/bind/bind_mf_cc.hpp>
 #include <boost/bind/bind_mf2_cc.hpp>
 
 #undef BOOST_BIND_MF_NAME
 #undef BOOST_BIND_MF_CC
+#undef BOOST_BIND_MF_NOEXCEPT
 
 #endif
 
@@ -2264,6 +2292,15 @@ template< class R, class T > struct add_cref< R (T::*) () const, 1 >
     typedef void type;
 };
 
+#ifdef __cpp_noexcept_function_type
+
+template< class R, class T > struct add_cref< R (T::*) () const noexcept, 1 >
+{
+    typedef void type;
+};
+
+#endif // __cpp_noexcept_function_type
+
 #endif // __IBMCPP__
 
 template<class R> struct isref
diff --git a/boost/bind/bind_cc.hpp b/boost/bind/bind_cc.hpp
index 35f8ece..278aa9a 100644
--- a/boost/bind/bind_cc.hpp
+++ b/boost/bind/bind_cc.hpp
@@ -13,28 +13,28 @@
 //
 
 template<class R>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (), _bi::list0>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) ())
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) () BOOST_BIND_NOEXCEPT, _bi::list0>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) () BOOST_BIND_NOEXCEPT)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) ();
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) () BOOST_BIND_NOEXCEPT;
     typedef _bi::list0 list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type());
 }
 
 template<class R, class B1, class A1>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1), typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1), A1 a1)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1) BOOST_BIND_NOEXCEPT, typename _bi::list_av_1<A1>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1) BOOST_BIND_NOEXCEPT, A1 a1)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_1<A1>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1));
 }
 
 template<class R, class B1, class B2, class A1, class A2>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2), A1 a1, A2 a2)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2) BOOST_BIND_NOEXCEPT, typename _bi::list_av_2<A1, A2>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
     return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
 }
@@ -42,10 +42,10 @@ template<class R, class B1, class B2, class A1, class A2>
 template<class R,
     class B1, class B2, class B3,
     class A1, class A2, class A3>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3) BOOST_BIND_NOEXCEPT, typename _bi::list_av_3<A1, A2, A3>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
 }
@@ -53,10 +53,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4) BOOST_BIND_NOEXCEPT, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
 }
@@ -64,10 +64,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5) BOOST_BIND_NOEXCEPT, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
 }
@@ -75,10 +75,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6) BOOST_BIND_NOEXCEPT, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
 }
@@ -86,10 +86,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_NOEXCEPT, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -97,10 +97,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_NOEXCEPT, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -108,10 +108,10 @@ template<class R,
 template<class R,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    _bi::bind_t<R, BOOST_BIND_ST R (BOOST_BIND_CC *) (B1, B2, B3, B4, B5, B6, B7, B8, B9) BOOST_BIND_NOEXCEPT, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    BOOST_BIND(BOOST_BIND_ST R (BOOST_BIND_CC *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9) BOOST_BIND_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
-    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
+    typedef BOOST_BIND_ST R (BOOST_BIND_CC *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9) BOOST_BIND_NOEXCEPT;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
     return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
diff --git a/boost/bind/bind_mf_cc.hpp b/boost/bind/bind_mf_cc.hpp
index e149384..bbfd371 100644
--- a/boost/bind/bind_mf_cc.hpp
+++ b/boost/bind/bind_mf_cc.hpp
@@ -17,7 +17,7 @@
 template<class R, class T,
     class A1>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
@@ -27,7 +27,7 @@ template<class R, class T,
 template<class R, class T,
     class A1>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
@@ -38,7 +38,7 @@ template<class Rt2, class R, class T,
     class A1>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
@@ -49,7 +49,7 @@ template<class Rt2, class R, class T,
     class A1>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T>, typename _bi::list_av_1<A1>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const BOOST_BIND_MF_NOEXCEPT, A1 a1)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf0)<R, T> F;
     typedef typename _bi::list_av_1<A1>::type list_type;
@@ -62,7 +62,7 @@ template<class R, class T,
     class B1,
     class A1, class A2>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
@@ -73,7 +73,7 @@ template<class R, class T,
     class B1,
     class A1, class A2>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
@@ -85,7 +85,7 @@ template<class Rt2, class R, class T,
     class A1, class A2>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
@@ -97,7 +97,7 @@ template<class Rt2, class R, class T,
     class A1, class A2>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf1)<R, T, B1> F;
     typedef typename _bi::list_av_2<A1, A2>::type list_type;
@@ -110,7 +110,7 @@ template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
@@ -121,7 +121,7 @@ template<class R, class T,
     class B1, class B2,
     class A1, class A2, class A3>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
@@ -133,7 +133,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
@@ -145,7 +145,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf2)<R, T, B1, B2> F;
     typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
@@ -158,7 +158,7 @@ template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
@@ -169,7 +169,7 @@ template<class R, class T,
     class B1, class B2, class B3,
     class A1, class A2, class A3, class A4>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
@@ -181,7 +181,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
@@ -193,7 +193,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf3)<R, T, B1, B2, B3> F;
     typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
@@ -206,7 +206,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
@@ -217,7 +217,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4,
     class A1, class A2, class A3, class A4, class A5>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
@@ -229,7 +229,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
@@ -241,7 +241,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf4)<R, T, B1, B2, B3, B4> F;
     typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
@@ -254,7 +254,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
@@ -265,7 +265,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5,
     class A1, class A2, class A3, class A4, class A5, class A6>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
@@ -277,7 +277,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
@@ -289,7 +289,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf5)<R, T, B1, B2, B3, B4, B5> F;
     typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
@@ -302,7 +302,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
@@ -313,7 +313,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
@@ -325,7 +325,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
@@ -337,7 +337,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf6)<R, T, B1, B2, B3, B4, B5, B6> F;
     typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
@@ -350,7 +350,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
@@ -361,7 +361,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
@@ -373,7 +373,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
@@ -385,7 +385,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf7)<R, T, B1, B2, B3, B4, B5, B6, B7> F;
     typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
@@ -398,7 +398,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
@@ -409,7 +409,7 @@ template<class R, class T,
     class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     _bi::bind_t<R, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
@@ -421,7 +421,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(mf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
@@ -433,7 +433,7 @@ template<class Rt2, class R, class T,
     class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
     typename boost::enable_if_c<!boost::core::is_same<Rt2, R>::value,
     _bi::bind_t<Rt2, _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
-    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+    >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const BOOST_BIND_MF_NOEXCEPT, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
 {
     typedef _mfi::BOOST_BIND_MF_NAME(cmf8)<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
     typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
diff --git a/boost/config.hpp b/boost/config.hpp
index d49bb27..f00a980 100644
--- a/boost/config.hpp
+++ b/boost/config.hpp
@@ -32,7 +32,7 @@
 
 // if we don't have a compiler config set, try and find one:
 #if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
-#  include <boost/config/select_compiler_config.hpp>
+#  include <boost/config/detail/select_compiler_config.hpp>
 #endif
 // if we have a compiler config, include it now:
 #ifdef BOOST_COMPILER_CONFIG
@@ -41,7 +41,7 @@
 
 // if we don't have a std library config set, try and find one:
 #if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
-#  include <boost/config/select_stdlib_config.hpp>
+#  include <boost/config/detail/select_stdlib_config.hpp>
 #endif
 // if we have a std library config, include it now:
 #ifdef BOOST_STDLIB_CONFIG
@@ -50,7 +50,7 @@
 
 // if we don't have a platform config set, try and find one:
 #if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
-#  include <boost/config/select_platform_config.hpp>
+#  include <boost/config/detail/select_platform_config.hpp>
 #endif
 // if we have a platform config, include it now:
 #ifdef BOOST_PLATFORM_CONFIG
@@ -58,7 +58,7 @@
 #endif
 
 // get config suffix code:
-#include <boost/config/suffix.hpp>
+#include <boost/config/detail/suffix.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
diff --git a/boost/config/auto_link.hpp b/boost/config/auto_link.hpp
index c71e803..271f837 100644
--- a/boost/config/auto_link.hpp
+++ b/boost/config/auto_link.hpp
@@ -45,6 +45,7 @@ BOOST_LIB_PREFIX
    + BOOST_LIB_TOOLSET
    + BOOST_LIB_THREAD_OPT
    + BOOST_LIB_RT_OPT
+   + BOOST_LIB_ARCH_AND_MODEL_OPT
    "-"
    + BOOST_LIB_VERSION
 
@@ -69,6 +70,9 @@ BOOST_LIB_RT_OPT:     A suffix that indicates the runtime library used,
                       p      STLport build.
                       n      STLport build without its IOStreams.
 
+BOOST_LIB_ARCH_AND_MODEL_OPT: The architecture and address model
+                              (-x32 or -x64 for x86/32 and x86/64 respectively)
+
 BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 
 
@@ -361,6 +365,20 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 
 #endif
 
+//
+// BOOST_LIB_ARCH_AND_MODEL_OPT
+//
+
+#if defined( _M_IX86 )
+#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-x32"
+#elif defined( _M_X64 )
+#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-x64"
+#elif defined( _M_ARM )
+#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-a32"
+#elif defined( _M_ARM64 )
+#  define BOOST_LIB_ARCH_AND_MODEL_OPT "-a64"
+#endif
+
 //
 // select linkage opt:
 //
@@ -380,6 +398,7 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
       && defined(BOOST_LIB_TOOLSET) \
       && defined(BOOST_LIB_THREAD_OPT) \
       && defined(BOOST_LIB_RT_OPT) \
+      && defined(BOOST_LIB_ARCH_AND_MODEL_OPT) \
       && defined(BOOST_LIB_VERSION)
 
 #ifdef BOOST_AUTO_LINK_TAGGED
@@ -393,14 +412,14 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #     pragma message ("Linking to lib file: " BOOST_STRINGIZE(BOOST_LIB_NAME) ".lib")
 #  endif
 #elif defined(BOOST_LIB_BUILDID)
-#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
-#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION "-" BOOST_STRINGIZE(BOOST_LIB_BUILDID) ".lib")
 #  endif
 #else
-#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+#  pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION ".lib")
 #  ifdef BOOST_LIB_DIAGNOSTIC
-#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib")
+#     pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT BOOST_LIB_ARCH_AND_MODEL_OPT "-" BOOST_LIB_VERSION ".lib")
 #  endif
 #endif
 
@@ -431,6 +450,9 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
 #if defined(BOOST_LIB_RT_OPT)
 #  undef BOOST_LIB_RT_OPT
 #endif
+#if defined(BOOST_LIB_ARCH_AND_MODEL_OPT)
+#  undef BOOST_LIB_ARCH_AND_MODEL_OPT
+#endif
 #if defined(BOOST_LIB_LINK_OPT)
 #  undef BOOST_LIB_LINK_OPT
 #endif
diff --git a/boost/config/compiler/borland.hpp b/boost/config/compiler/borland.hpp
index b749496..fa891de 100644
--- a/boost/config/compiler/borland.hpp
+++ b/boost/config/compiler/borland.hpp
@@ -228,6 +228,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if __BORLANDC__ >= 0x590
 #  define BOOST_HAS_TR1_HASH
 
diff --git a/boost/config/compiler/clang.hpp b/boost/config/compiler/clang.hpp
index 175229c..0fdf331 100644
--- a/boost/config/compiler/clang.hpp
+++ b/boost/config/compiler/clang.hpp
@@ -27,6 +27,10 @@
 #define __has_attribute(x) 0
 #endif
 
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
 #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
@@ -282,6 +286,16 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+// Clang 3.9+ in c++1z
+#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if __cplusplus < 201103L
 #define BOOST_NO_CXX11_SFINAE_EXPR
 #endif
@@ -296,9 +310,19 @@
 #define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
 #endif
 
+#if (__clang_major__ == 3) && (__clang_minor__ == 0)
+// Apparently a clang bug:
+#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#endif
+
 // Clang has supported the 'unused' attribute since the first release.
 #define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
 
+// Type aliasing hint.
+#if __has_attribute(__may_alias__)
+#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+#endif
+
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "Clang version " __clang_version__
 #endif
diff --git a/boost/config/compiler/codegear.hpp b/boost/config/compiler/codegear.hpp
index 3c5262f..44ca842 100644
--- a/boost/config/compiler/codegear.hpp
+++ b/boost/config/compiler/codegear.hpp
@@ -154,6 +154,19 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 //
 // TR1 macros:
 //
diff --git a/boost/config/compiler/common_edg.hpp b/boost/config/compiler/common_edg.hpp
index eab9378..d49ceb6 100644
--- a/boost/config/compiler/common_edg.hpp
+++ b/boost/config/compiler/common_edg.hpp
@@ -138,6 +138,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #ifdef c_plusplus
 // EDG has "long long" in non-strict mode
 // However, some libraries have insufficient "long long" support
diff --git a/boost/config/compiler/cray.hpp b/boost/config/compiler/cray.hpp
index eab5287..5f81078 100644
--- a/boost/config/compiler/cray.hpp
+++ b/boost/config/compiler/cray.hpp
@@ -10,7 +10,7 @@
 
 #define BOOST_COMPILER "Cray C version " BOOST_STRINGIZE(_RELEASE)
 
-#if _RELEASE < 8
+#if _RELEASE_MAJOR < 8
 #  error "Boost is not configured for Cray compilers prior to version 8, please try the configure script."
 #endif
 
@@ -21,9 +21,9 @@
 #  error "Unsupported Cray compiler, please try running the configure script."
 #endif
 
+#if _RELEASE_MINOR < 5 || __cplusplus < 201100
 #include <boost/config/compiler/common_edg.hpp>
 
-
 //
 //
 #define BOOST_NO_CXX11_STATIC_ASSERT
@@ -90,5 +90,35 @@
 #define __ATOMIC_SEQ_CST 5
 #endif
 
+#else  /* _RELEASE_MINOR */
+
+#define BOOST_HAS_VARIADIC_TMPL
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
+#define BOOST_HAS_TR1_COMPLEX_OVERLOADS
+#define BOOST_HAS_STDINT_H
+#define BOOST_HAS_STATIC_ASSERT
+#define BOOST_HAS_SIGACTION
+#define BOOST_HAS_SCHED_YIELD
+#define BOOST_HAS_RVALUE_REFS
+#define BOOST_HAS_PTHREADS
+#define BOOST_HAS_PTHREAD_YIELD
+#define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#define BOOST_HAS_NRVO
+#define BOOST_HAS_NL_TYPES_H
+#define BOOST_HAS_NANOSLEEP
+#define BOOST_NO_CXX11_SMART_PTR
+#define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#define BOOST_NO_CXX14_CONSTEXPR
+#define BOOST_HAS_LONG_LONG
+#define BOOST_HAS_FLOAT128
+
+#if __cplusplus < 201400
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+#endif /* __cpluspus */
+
+#endif /* _RELEASE_MINOR */
+
 
 
diff --git a/boost/config/compiler/diab.hpp b/boost/config/compiler/diab.hpp
new file mode 100644
index 0000000..0de72d0
--- /dev/null
+++ b/boost/config/compiler/diab.hpp
@@ -0,0 +1,19 @@
+//  (C) Copyright Brian Kuhl 2016.
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Check this is a recent EDG based compiler, otherwise we don't support it here:
+
+
+#ifndef __EDG_VERSION__
+#     error "Unknown Diab compiler version - please run the configure tests and report the results"
+#endif
+
+#include "boost/config/compiler/common_edg.hpp"
+
+#define BOOST_HAS_LONG_LONG
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_HDR_CODECVT
+#define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__)
diff --git a/boost/config/compiler/digitalmars.hpp b/boost/config/compiler/digitalmars.hpp
index e371a68..e4c5afd 100644
--- a/boost/config/compiler/digitalmars.hpp
+++ b/boost/config/compiler/digitalmars.hpp
@@ -114,6 +114,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if (__DMC__ <= 0x840)
 #error "Compiler not supported or configured - please reconfigure"
 #endif
diff --git a/boost/config/compiler/gcc.hpp b/boost/config/compiler/gcc.hpp
index c82cbc7..c67ab81 100644
--- a/boost/config/compiler/gcc.hpp
+++ b/boost/config/compiler/gcc.hpp
@@ -288,11 +288,37 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
+#if __GNUC__ >= 7
+#  define BOOST_FALLTHROUGH __attribute__((fallthrough))
+#endif
+
+#ifdef __MINGW32__
+// Currently (June 2017) thread_local is broken on mingw for all current compiler releases, see
+// https://sourceforge.net/p/mingw-w64/bugs/527/
+// Not setting this causes program termination on thread exit.
+#define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+
 //
 // Unused attribute:
 #if __GNUC__ >= 4
 #  define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
 #endif
+
+// Type aliasing hint. Supported since gcc 3.3.
+#define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+
 //
 // __builtin_unreachable:
 #if BOOST_GCC_VERSION >= 40800
@@ -316,10 +342,10 @@
 #  error "Compiler not configured - please reconfigure"
 #endif
 //
-// last known and checked version is 4.9:
-#if (BOOST_GCC_VERSION > 40900)
+// last known and checked version is 7.1:
+#if (BOOST_GCC_VERSION > 70100)
 #  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
+#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
 #  else
 // we don't emit warnings here anymore since there are no defect macros defined for
 // gcc post 3.4, so any failures are gcc regressions...
diff --git a/boost/config/compiler/gcc_xml.hpp b/boost/config/compiler/gcc_xml.hpp
index 63b08ac..2b47585 100644
--- a/boost/config/compiler/gcc_xml.hpp
+++ b/boost/config/compiler/gcc_xml.hpp
@@ -92,6 +92,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__
 
 
diff --git a/boost/config/compiler/intel.hpp b/boost/config/compiler/intel.hpp
index f55189a..00396b0 100644
--- a/boost/config/compiler/intel.hpp
+++ b/boost/config/compiler/intel.hpp
@@ -311,6 +311,12 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 #  define BOOST_SYMBOL_IMPORT
 #  define BOOST_SYMBOL_VISIBLE __attribute__((visibility("default")))
 #endif
+
+// Type aliasing hint
+#if defined(__GNUC__) && (BOOST_INTEL_CXX_VERSION >= 1300)
+#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+#endif
+
 //
 // C++0x features
 // For each feature we need to check both the Intel compiler version, 
@@ -545,7 +551,7 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 // last known and checked version:
 #if (BOOST_INTEL_CXX_VERSION > 1700)
 #  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
+#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
 #  elif defined(_MSC_VER)
 //
 //      We don't emit this warning any more, since we have so few
diff --git a/boost/config/compiler/metrowerks.hpp b/boost/config/compiler/metrowerks.hpp
index 8d42563..99ff0f5 100644
--- a/boost/config/compiler/metrowerks.hpp
+++ b/boost/config/compiler/metrowerks.hpp
@@ -157,6 +157,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 
 //
diff --git a/boost/config/compiler/mpw.hpp b/boost/config/compiler/mpw.hpp
index 1b8d39e..d954434 100644
--- a/boost/config/compiler/mpw.hpp
+++ b/boost/config/compiler/mpw.hpp
@@ -106,6 +106,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 //
 // versions check:
 // we don't support MPW prior to version 8.9:
diff --git a/boost/config/compiler/nvcc.hpp b/boost/config/compiler/nvcc.hpp
index b31d4f4..f21b9b5 100644
--- a/boost/config/compiler/nvcc.hpp
+++ b/boost/config/compiler/nvcc.hpp
@@ -11,6 +11,13 @@
 #  define BOOST_COMPILER "NVIDIA CUDA C++ Compiler"
 #endif
 
+#if defined(__CUDACC_VER_MAJOR__) && defined(__CUDACC_VER_MINOR__) && defined(__CUDACC_VER_BUILD__)
+#  define BOOST_CUDA_VERSION __CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__
+#else
+// We don't really know what the CUDA version is, but it's definitely before 7.5:
+#  define BOOST_CUDA_VERSION 7000000
+#endif
+
 // NVIDIA Specific support
 // BOOST_GPU_ENABLED : Flag a function or a method as being enabled on the host and device
 #define BOOST_GPU_ENABLED __host__ __device__
@@ -19,14 +26,33 @@
 // https://svn.boost.org/trac/boost/ticket/11897
 // This is fixed in 7.5. As the following version macro was introduced in 7.5 an existance
 // check is enough to detect versions < 7.5
-#if !defined(__CUDACC_VER__) || (__CUDACC_VER__ < 70500)
+#if BOOST_CUDA_VERSION < 7050000
 #   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
 #endif
 // The same bug is back again in 8.0:
-#if (__CUDACC_VER__ > 80000) && (__CUDACC_VER__ < 80100)
+#if (BOOST_CUDA_VERSION > 8000000) && (BOOST_CUDA_VERSION < 8010000)
 #   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
 #endif
 // Most recent CUDA (8.0) has no constexpr support in msvc mode:
 #if defined(_MSC_VER)
 #  define BOOST_NO_CXX11_CONSTEXPR
 #endif
+
+#ifdef __CUDACC__
+//
+// When compiing .cu files, there's a bunch of stuff that doesn't work with msvc:
+//
+#if defined(_MSC_VER)
+#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+//
+// And this one effects the NVCC front end,
+// See https://svn.boost.org/trac/boost/ticket/13049
+//
+#if (BOOST_CUDA_VERSION >= 8000000) && (BOOST_CUDA_VERSION < 8010000)
+#  define BOOST_NO_CXX11_NOEXCEPT
+#endif
+
+#endif
+
diff --git a/boost/config/compiler/pathscale.hpp b/boost/config/compiler/pathscale.hpp
index 016ad5a..94b3f91 100644
--- a/boost/config/compiler/pathscale.hpp
+++ b/boost/config/compiler/pathscale.hpp
@@ -12,7 +12,12 @@
 #  define BOOST_COMPILER "PathScale EKOPath C++ Compiler version " __PATHSCALE__
 #endif
 
-#if __PATHCC__ >= 4
+#if __PATHCC__ >= 6 
+// PathCC is based on clang, and supports the __has_*() builtins used 
+// to detect features in clang.hpp. Since the clang toolset is much 
+// better maintained, it is more convenient to reuse its definitions. 
+#  include "boost/config/compiler/clang.hpp"
+#elif __PATHCC__ >= 4 
 #  define BOOST_MSVC6_MEMBER_TEMPLATES
 #  define BOOST_HAS_UNISTD_H
 #  define BOOST_HAS_STDINT_H
@@ -113,4 +118,15 @@
 #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
+
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
 #endif
diff --git a/boost/config/compiler/pgi.hpp b/boost/config/compiler/pgi.hpp
index af70051..4e909d8 100644
--- a/boost/config/compiler/pgi.hpp
+++ b/boost/config/compiler/pgi.hpp
@@ -1,4 +1,5 @@
 //  (C) Copyright Noel Belcourt 2007.
+//  Copyright 2017, NVIDIA CORPORATION.
 //  Use, modification and distribution are subject to the
 //  Boost Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -10,148 +11,13 @@
 #define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__
 #define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 
-//
-// Threading support:
-// Turn this on unconditionally here, it will get turned off again later
-// if no threading API is detected.
-//
+// PGI is mostly GNU compatible.  So start with that.
+#include <boost/config/compiler/gcc.hpp>
 
-#if __PGIC__ >= 11
+// Now adjust for things that are different.
 
-// options requested by configure --enable-test
-#define BOOST_HAS_PTHREADS
-#define BOOST_HAS_THREADS
-#define BOOST_HAS_PTHREAD_YIELD
-#define BOOST_HAS_NRVO
-#define BOOST_HAS_LONG_LONG
-
-// options --enable-test wants undefined
-#undef BOOST_NO_STDC_NAMESPACE
-#undef BOOST_NO_EXCEPTION_STD_NAMESPACE
-#undef BOOST_DEDUCED_TYPENAME
-
-#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
-#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
-#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CXX11_AUTO_DECLARATIONS
-
-#elif __PGIC__ >= 10
-
-// options requested by configure --enable-test
-#define BOOST_HAS_THREADS
-#define BOOST_HAS_NRVO
-#define BOOST_HAS_LONG_LONG
-#if defined(linux) || defined(__linux) || defined(__linux__)
-#  define BOOST_HAS_STDINT_H
-#endif
-
-// options --enable-test wants undefined
-#undef BOOST_NO_STDC_NAMESPACE
-#undef BOOST_NO_EXCEPTION_STD_NAMESPACE
-#undef BOOST_DEDUCED_TYPENAME
-
-#elif __PGIC__ >= 7
-
-#define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
-#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
-#define BOOST_NO_SWPRINTF
-#define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
-#define BOOST_NO_CXX11_AUTO_DECLARATIONS
-
-#else
-
-#  error "Pgi compiler not configured - please reconfigure"
-
-#endif
-//
-// C++0x features
-//
-//   See boost\config\suffix.hpp for BOOST_NO_LONG_LONG
-//
-#define BOOST_NO_CXX11_CHAR16_T
-#define BOOST_NO_CXX11_CHAR32_T
-#define BOOST_NO_CXX11_CONSTEXPR
-#define BOOST_NO_CXX11_DECLTYPE
-#define BOOST_NO_CXX11_DECLTYPE_N3276
-#define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
-#define BOOST_NO_CXX11_DELETED_FUNCTIONS
-#define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-#define BOOST_NO_CXX11_EXTERN_TEMPLATE
-#define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-#define BOOST_NO_CXX11_LAMBDAS
-#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
-#define BOOST_NO_CXX11_NOEXCEPT
-#define BOOST_NO_CXX11_NULLPTR
-#define BOOST_NO_CXX11_NUMERIC_LIMITS
-#define BOOST_NO_CXX11_RANGE_BASED_FOR
-#define BOOST_NO_CXX11_RAW_LITERALS
-#define BOOST_NO_CXX11_RVALUE_REFERENCES
-#define BOOST_NO_CXX11_SCOPED_ENUMS
-#define BOOST_NO_SFINAE_EXPR
-#define BOOST_NO_CXX11_SFINAE_EXPR
-#define BOOST_NO_CXX11_STATIC_ASSERT
-#define BOOST_NO_SWPRINTF
-#define BOOST_NO_CXX11_TEMPLATE_ALIASES
-#define BOOST_NO_CXX11_UNICODE_LITERALS
-#define BOOST_NO_CXX11_VARIADIC_TEMPLATES
-#define BOOST_NO_CXX11_VARIADIC_MACROS
-#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
-
-#define BOOST_NO_CXX11_HDR_UNORDERED_SET
-#define BOOST_NO_CXX11_HDR_UNORDERED_MAP
-#define BOOST_NO_CXX11_HDR_TYPEINDEX
-#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
-#define BOOST_NO_CXX11_HDR_TUPLE
-#define BOOST_NO_CXX11_HDR_THREAD
-#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
-#define BOOST_NO_CXX11_HDR_REGEX
-#define BOOST_NO_CXX11_HDR_RATIO
-#define BOOST_NO_CXX11_HDR_RANDOM
-#define BOOST_NO_CXX11_HDR_MUTEX
-#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#define BOOST_NO_CXX11_HDR_FUTURE
-#define BOOST_NO_CXX11_HDR_FORWARD_LIST
-#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
-#define BOOST_NO_CXX11_HDR_CODECVT
-#define BOOST_NO_CXX11_HDR_CHRONO
-#define BOOST_NO_CXX11_HDR_ARRAY
-#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
-#define BOOST_NO_CXX11_ALIGNAS
-#define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
-#define BOOST_NO_CXX11_INLINE_NAMESPACES
-#define BOOST_NO_CXX11_REF_QUALIFIERS
-#define BOOST_NO_CXX11_FINAL
-#define BOOST_NO_CXX11_THREAD_LOCAL
-
-// C++ 14:
-#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
-#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
-#endif
-#if !defined(__cpp_binary_literals) || (__cpp_binary_literals < 201304)
-#  define BOOST_NO_CXX14_BINARY_LITERALS
-#endif
-#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
-#  define BOOST_NO_CXX14_CONSTEXPR
-#endif
-#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
-#  define BOOST_NO_CXX14_DECLTYPE_AUTO
-#endif
-#if (__cplusplus < 201304) // There's no SD6 check for this....
-#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
-#endif
-#if !defined(__cpp_generic_lambdas) || (__cpp_generic_lambdas < 201304)
-#  define BOOST_NO_CXX14_GENERIC_LAMBDAS
-#endif
-#if !defined(__cpp_init_captures) || (__cpp_init_captures < 201304)
-#  define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
-#endif
-#if !defined(__cpp_return_type_deduction) || (__cpp_return_type_deduction < 201304)
-#  define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
-#endif
-#if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
-#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
-#endif
-//
-// version check:
-// probably nothing to do here?
+// __float128 is a typedef, not a distinct type.
+#undef BOOST_HAS_FLOAT128
 
+// __int128 is not supported.
+#undef BOOST_HAS_INT128
diff --git a/boost/config/compiler/sunpro_cc.hpp b/boost/config/compiler/sunpro_cc.hpp
index cdd30b1..54ad77a 100644
--- a/boost/config/compiler/sunpro_cc.hpp
+++ b/boost/config/compiler/sunpro_cc.hpp
@@ -172,6 +172,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 // Turn on threading support for Solaris 12.
 // Ticket #11972
 #if (__SUNPRO_CC >= 0x5140) && defined(__SunOS_5_12) && !defined(BOOST_HAS_THREADS)
@@ -191,9 +202,9 @@
 #error "Compiler not supported or configured - please reconfigure"
 #endif
 //
-// last known and checked version is 0x590:
-#if (__SUNPRO_CC > 0x590)
+// last known and checked version:
+#if (__SUNPRO_CC > 0x5150)
 #  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
+#     error "Boost.Config is older than your compiler - please check for an updated Boost release."
 #  endif
 #endif
diff --git a/boost/config/compiler/vacpp.hpp b/boost/config/compiler/vacpp.hpp
index b75a1bd..c8400a3 100644
--- a/boost/config/compiler/vacpp.hpp
+++ b/boost/config/compiler/vacpp.hpp
@@ -65,6 +65,11 @@
 #define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
 #endif
 
+// Type aliasing hint. Supported since XL C++ 13.1
+#if (__IBMCPP__ >= 1310)
+#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+#endif
+
 //
 // C++0x features
 //
@@ -162,3 +167,14 @@
 #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
+
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
diff --git a/boost/config/compiler/visualc.hpp b/boost/config/compiler/visualc.hpp
index 760e283..d946561 100644
--- a/boost/config/compiler/visualc.hpp
+++ b/boost/config/compiler/visualc.hpp
@@ -107,7 +107,7 @@
 //
 // TR1 features:
 //
-#if _MSC_VER >= 1700
+#if (_MSC_VER >= 1700) && defined(_HAS_CXX17) && (_HAS_CXX17 > 0)
 // # define BOOST_HAS_TR1_HASH			// don't know if this is true yet.
 // # define BOOST_HAS_TR1_TYPE_TRAITS	// don't know if this is true yet.
 # define BOOST_HAS_TR1_UNORDERED_MAP
@@ -194,7 +194,12 @@
 //
 #if (_MSC_VER < 1910)
 #  define BOOST_NO_CXX14_AGGREGATE_NSDMI
-#  define BOOST_NO_CXX14_CONSTEXPR
+#endif
+
+// C++17 features supported by VC++ 14.1 (Visual Studio 2017) Update 3
+//
+#if (_MSC_VER < 1911) || (_MSVC_LANG < 201703)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
 #endif
 
 // MSVC including version 14 has not yet completely
@@ -218,6 +223,11 @@
 //
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
 #define BOOST_NO_CXX11_SFINAE_EXPR
+// C++ 14:
+#  define BOOST_NO_CXX14_CONSTEXPR
+// C++ 17:
+#define BOOST_NO_CXX17_INLINE_VARIABLES
+#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
 
 //
 // Things that don't work in clr mode:
@@ -284,7 +294,7 @@
 #      endif
 #   endif
 # else
-#   if _MSC_VER < 1310
+#   if _MSC_VER < 1200
       // Note: Versions up to 7.0 aren't supported.
 #     define BOOST_COMPILER_VERSION 5.0
 #   elif _MSC_VER < 1300
@@ -316,11 +326,11 @@
 #endif
 
 //
-// last known and checked version is 19.10.25017 (VC++ 2017):
-#if (_MSC_VER > 1910)
+// last known and checked version is 19.11.25547 (VC++ 2017.4):
+#if (_MSC_VER > 1911)
 #  if defined(BOOST_ASSERT_CONFIG)
-#     error "Unknown compiler version - please run the configure tests and report the results"
-#  else
-#     pragma message("Unknown compiler version - please run the configure tests and report the results")
+#     error "Boost.Config is older than your current compiler version."
+#  elif !defined(BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE)
+#     pragma message("Info: Boost.Config is older than your compiler version - probably nothing bad will happen - but you may wish to look for an update Boost version.  Define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE to suppress this message.")
 #  endif
 #endif
diff --git a/boost/config/compiler/xlcpp.hpp b/boost/config/compiler/xlcpp.hpp
index 2aaafc3..a4c66e4 100644
--- a/boost/config/compiler/xlcpp.hpp
+++ b/boost/config/compiler/xlcpp.hpp
@@ -23,6 +23,10 @@
 #define __has_extension __has_feature
 #endif
 
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
 #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
@@ -238,6 +242,16 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+// Clang 3.9+ in c++1z
+#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if !__has_feature(cxx_thread_local)
 #  define BOOST_NO_CXX11_THREAD_LOCAL
 #endif
@@ -253,6 +267,11 @@
 #  define BOOST_ATTRIBUTE_UNUSED __attribute__((unused))
 #endif
 
+// Type aliasing hint.
+#if __has_attribute(__may_alias__)
+#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+#endif
+
 #ifndef BOOST_COMPILER
 #  define BOOST_COMPILER "Clang version " __clang_version__
 #endif
diff --git a/boost/config/compiler/xlcpp_zos.hpp b/boost/config/compiler/xlcpp_zos.hpp
new file mode 100644
index 0000000..bc785b8
--- /dev/null
+++ b/boost/config/compiler/xlcpp_zos.hpp
@@ -0,0 +1,169 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org for most recent version.
+
+//  Compiler setup for IBM z/OS XL C/C++ compiler.
+
+// Oldest compiler version currently supported is 2.1 (V2R1)
+#if !defined(__IBMCPP__) || !defined(__COMPILER_VER__) || __COMPILER_VER__ < 0x42010000
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+#if __COMPILER_VER__ > 0x42010000
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+#define BOOST_COMPILER "IBM z/OS XL C/C++ version " BOOST_STRINGIZE(__COMPILER_VER__)
+#define BOOST_XLCPP_ZOS __COMPILER_VER__
+
+// -------------------------------------
+
+#include <features.h> // For __UU, __C99, __TR1, ...
+
+#if !defined(__IBMCPP_DEFAULTED_AND_DELETED_FUNCTIONS)
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
+// -------------------------------------
+
+#if defined(__UU) || defined(__C99) || defined(__TR1)
+#  define BOOST_HAS_LOG1P
+#  define BOOST_HAS_EXPM1
+#endif
+
+#if defined(__C99) || defined(__TR1)
+#  define BOOST_HAS_STDINT_H
+#else
+#  define BOOST_NO_FENV_H
+#endif
+
+// -------------------------------------
+
+#define BOOST_HAS_NRVO
+
+#if !defined(__RTTI_ALL__)
+#  define BOOST_NO_RTTI
+#endif
+
+#if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+
+#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL)
+#  define BOOST_HAS_LONG_LONG
+#else
+#  define BOOST_NO_LONG_LONG
+#endif
+
+#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL) || defined(_LP64)
+#  define BOOST_HAS_MS_INT64
+#endif
+
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
+
+#if defined(__IBMCPP_VARIADIC_TEMPLATES)
+#  define BOOST_HAS_VARIADIC_TMPL
+#else
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+
+#if defined(__IBMCPP_STATIC_ASSERT)
+#  define BOOST_HAS_STATIC_ASSERT
+#else
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+
+#if defined(__IBMCPP_RVALUE_REFERENCES)
+#  define BOOST_HAS_RVALUE_REFS
+#else
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+
+#if !defined(__IBMCPP_SCOPED_ENUM)
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+
+#if !defined(__IBMCPP_EXPLICIT_CONVERSION_OPERATORS)
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+
+#if !defined(__IBMCPP_DECLTYPE)
+#  define BOOST_NO_CXX11_DECLTYPE
+#else
+#  define BOOST_HAS_DECLTYPE
+#endif
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+
+#if !defined(__IBMCPP_INLINE_NAMESPACE)
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+#if !defined(__IBMCPP_AUTO_TYPEDEDUCTION)
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+#if !defined(__IBM_CHAR32_T__)
+#  define BOOST_NO_CXX11_CHAR32_T
+#endif
+#if !defined(__IBM_CHAR16_T__)
+#  define BOOST_NO_CXX11_CHAR16_T
+#endif
+
+#if !defined(__IBMCPP_CONSTEXPR)
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#define BOOST_NO_CXX14_DECLTYPE_AUTO
+#define BOOST_NO_CXX14_CONSTEXPR
+#define BOOST_NO_CXX14_BINARY_LITERALS
+#define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#define BOOST_NO_CXX17_INLINE_VARIABLES
+#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+
+// -------------------------------------
+
+#if defined(__IBM_ATTRIBUTES)
+#  define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+#  define BOOST_NOINLINE __attribute__ ((__noinline__))
+#  define BOOST_MAY_ALIAS __attribute__((__may_alias__))
+// No BOOST_ALIGNMENT - explicit alignment support is broken (V2R1).
+#endif
+
+extern "builtin" long __builtin_expect(long, long);
+
+#define BOOST_LIKELY(x) __builtin_expect((x) && true, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect((x) && true, 0)
diff --git a/boost/config/detail/posix_features.hpp b/boost/config/detail/posix_features.hpp
new file mode 100644
index 0000000..d129547
--- /dev/null
+++ b/boost/config/detail/posix_features.hpp
@@ -0,0 +1,95 @@
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+// All POSIX feature tests go in this file,
+// Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well
+// _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's
+// may be present but none-functional unless _POSIX_C_SOURCE and
+// _XOPEN_SOURCE have been defined to the right value (it's up
+// to the user to do this *before* including any header, although
+// in most cases the compiler will do this for you).
+
+#  if defined(BOOST_HAS_UNISTD_H)
+#     include <unistd.h>
+
+      // XOpen has <nl_types.h>, but is this the correct version check?
+#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3)
+#        define BOOST_HAS_NL_TYPES_H
+#     endif
+
+      // POSIX version 6 requires <stdint.h>
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100)
+#        define BOOST_HAS_STDINT_H
+#     endif
+
+      // POSIX version 2 requires <dirent.h>
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L)
+#        define BOOST_HAS_DIRENT_H
+#     endif
+
+      // POSIX version 3 requires <signal.h> to have sigaction:
+#     if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L)
+#        define BOOST_HAS_SIGACTION
+#     endif
+      // POSIX defines _POSIX_THREADS > 0 for pthread support,
+      // however some platforms define _POSIX_THREADS without
+      // a value, hence the (_POSIX_THREADS+0 >= 0) check.
+      // Strictly speaking this may catch platforms with a
+      // non-functioning stub <pthreads.h>, but such occurrences should
+      // occur very rarely if at all.
+#     if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS)
+#        define BOOST_HAS_PTHREADS
+#     endif
+
+      // BOOST_HAS_NANOSLEEP:
+      // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME:
+#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \
+             || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
+#        define BOOST_HAS_NANOSLEEP
+#     endif
+
+      // BOOST_HAS_CLOCK_GETTIME:
+      // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME
+      // but at least one platform - linux - defines that flag without
+      // defining clock_gettime):
+#     if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0))
+#        define BOOST_HAS_CLOCK_GETTIME
+#     endif
+
+      // BOOST_HAS_SCHED_YIELD:
+      // This is predicated on _POSIX_PRIORITY_SCHEDULING or
+      // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME.
+#     if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\
+            || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\
+            || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0))
+#        define BOOST_HAS_SCHED_YIELD
+#     endif
+
+      // BOOST_HAS_GETTIMEOFDAY:
+      // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE:
+      // These are predicated on _XOPEN_VERSION, and appears to be first released
+      // in issue 4, version 2 (_XOPEN_VERSION > 500).
+      // Likewise for the functions log1p and expm1.
+#     if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500)
+#        define BOOST_HAS_GETTIMEOFDAY
+#        if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500)
+#           define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#        endif
+#        ifndef BOOST_HAS_LOG1P
+#           define BOOST_HAS_LOG1P
+#        endif
+#        ifndef BOOST_HAS_EXPM1
+#           define BOOST_HAS_EXPM1
+#        endif
+#     endif
+
+#  endif
+
+
+
+
diff --git a/boost/config/detail/select_compiler_config.hpp b/boost/config/detail/select_compiler_config.hpp
new file mode 100644
index 0000000..ced8443
--- /dev/null
+++ b/boost/config/detail/select_compiler_config.hpp
@@ -0,0 +1,158 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Martin Wille 2003.
+//  (C) Copyright Guillaume Melquiond 2003.
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//   http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for most recent version.
+
+// locate which compiler we are using and define
+// BOOST_COMPILER_CONFIG as needed: 
+
+#if defined __CUDACC__
+//  NVIDIA CUDA C++ compiler for GPU
+#   include "boost/config/compiler/nvcc.hpp"
+
+#endif
+
+#if defined(__GCCXML__)
+// GCC-XML emulates other compilers, it has to appear first here!
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc_xml.hpp"
+
+#elif defined(_CRAYC)
+// EDG based Cray compiler:
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/cray.hpp"
+
+#elif defined __COMO__
+//  Comeau C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp"
+
+#elif defined(__PATHSCALE__) && (__PATHCC__ >= 4)
+// PathScale EKOPath compiler (has to come before clang and gcc)
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pathscale.hpp"
+
+#elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)
+//  Intel
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp"
+
+#elif defined __clang__ && !defined(__CUDACC__) && !defined(__ibmxl__)
+// when using clang and cuda at same time, you want to appear as gcc
+//  Clang C++ emulates GCC, so it has to appear early.
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/clang.hpp"
+
+#elif defined __DMC__
+//  Digital Mars C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"
+
+#elif defined __DCC__
+//  Wind River Diab C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/diab.hpp"
+
+#elif defined(__PGI)
+//  Portland Group Inc.
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/pgi.hpp"
+
+# elif defined(__GNUC__) && !defined(__ibmxl__)
+//  GNU C++:
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
+
+#elif defined __KCC
+//  Kai C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp"
+
+#elif defined __sgi
+//  SGI MIPSpro C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp"
+
+#elif defined __DECCXX
+//  Compaq Tru64 Unix cxx
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp"
+
+#elif defined __ghs
+//  Greenhills C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp"
+
+#elif defined __CODEGEARC__
+//  CodeGear - must be checked for before Borland
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/codegear.hpp"
+
+#elif defined __BORLANDC__
+//  Borland
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp"
+
+#elif defined  __MWERKS__
+//  Metrowerks CodeWarrior
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp"
+
+#elif defined  __SUNPRO_CC
+//  Sun Workshop Compiler C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp"
+
+#elif defined __HP_aCC
+//  HP aCC
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp"
+
+#elif defined(__MRC__) || defined(__SC__)
+//  MPW MrCpp or SCpp
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
+//  IBM z/OS XL C/C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp_zos.hpp"
+
+#elif defined(__ibmxl__)
+//  IBM XL C/C++ for Linux (Little Endian)
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp.hpp"
+
+#elif defined(__IBMCPP__)
+//  IBM Visual Age or IBM XL C/C++ for Linux (Big Endian)
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp"
+
+#elif defined _MSC_VER
+//  Microsoft Visual C++
+//
+//  Must remain the last #elif since some other vendors (Metrowerks, for
+//  example) also #define _MSC_VER
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp"
+
+#elif defined (BOOST_ASSERT_CONFIG)
+// this must come last - generate an error if we don't
+// recognise the compiler:
+#  error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)"
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the headers we *might* include:
+//
+#include <boost/config/compiler/gcc_xml.hpp>
+#include <boost/config/compiler/cray.hpp>
+#include <boost/config/compiler/comeau.hpp>
+#include <boost/config/compiler/pathscale.hpp>
+#include <boost/config/compiler/intel.hpp>
+#include <boost/config/compiler/clang.hpp>
+#include <boost/config/compiler/digitalmars.hpp>
+#include <boost/config/compiler/gcc.hpp>
+#include <boost/config/compiler/kai.hpp>
+#include <boost/config/compiler/sgi_mipspro.hpp>
+#include <boost/config/compiler/compaq_cxx.hpp>
+#include <boost/config/compiler/greenhills.hpp>
+#include <boost/config/compiler/codegear.hpp>
+#include <boost/config/compiler/borland.hpp>
+#include <boost/config/compiler/metrowerks.hpp>
+#include <boost/config/compiler/sunpro_cc.hpp>
+#include <boost/config/compiler/hp_acc.hpp>
+#include <boost/config/compiler/mpw.hpp>
+#include <boost/config/compiler/xlcpp_zos.hpp>
+#include <boost/config/compiler/xlcpp.hpp>
+#include <boost/config/compiler/vacpp.hpp>
+#include <boost/config/compiler/pgi.hpp>
+#include <boost/config/compiler/visualc.hpp>
+
+#endif
+
diff --git a/boost/config/detail/select_platform_config.hpp b/boost/config/detail/select_platform_config.hpp
new file mode 100644
index 0000000..b36eca5
--- /dev/null
+++ b/boost/config/detail/select_platform_config.hpp
@@ -0,0 +1,142 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2002. 
+//  (C) Copyright Jens Maurer 2001. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for most recent version.
+
+// locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed.
+// Note that we define the headers to include using "header_name" not
+// <header_name> in order to prevent macro expansion within the header
+// name (for example "linux" is a macro on linux systems).
+
+#if (defined(linux) || defined(__linux) || defined(__linux__) || defined(__GNU__) || defined(__GLIBC__)) && !defined(_CRAYC)
+// linux, also other platforms (Hurd etc) that use GLIBC, should these really have their own config headers though?
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp"
+
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+// BSD:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp"
+
+#elif defined(sun) || defined(__sun)
+// solaris:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp"
+
+#elif defined(__sgi)
+// SGI Irix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp"
+
+#elif defined(__hpux)
+// hp unix:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp"
+
+#elif defined(__CYGWIN__)
+// cygwin is not win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp"
+
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+// win32:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp"
+
+#elif defined(__HAIKU__)
+// Haiku
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/haiku.hpp"
+
+#elif defined(__BEOS__)
+// BeOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp"
+
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+// MacOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
+
+#elif defined(__TOS_MVS__)
+// IBM z/OS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/zos.hpp"
+
+#elif defined(__IBMCPP__) || defined(_AIX)
+// IBM AIX
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
+
+#elif defined(__amigaos__)
+// AmigaOS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp"
+
+#elif defined(__QNXNTO__)
+// QNX:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/qnxnto.hpp"
+
+#elif defined(__VXWORKS__)
+// vxWorks:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vxworks.hpp"
+
+#elif defined(__SYMBIAN32__) 
+// Symbian: 
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/symbian.hpp" 
+
+#elif defined(_CRAYC)
+// Cray:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cray.hpp" 
+
+#elif defined(__VMS) 
+// VMS:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/vms.hpp" 
+
+#elif defined(__CloudABI__)
+// Nuxi CloudABI:
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/cloudabi.hpp"
+#else
+
+#  if defined(unix) \
+      || defined(__unix) \
+      || defined(_XOPEN_SOURCE) \
+      || defined(_POSIX_SOURCE)
+
+   // generic unix platform:
+
+#  ifndef BOOST_HAS_UNISTD_H
+#     define BOOST_HAS_UNISTD_H
+#  endif
+
+#  include <boost/config/detail/posix_features.hpp>
+
+#  endif
+
+#  if defined (BOOST_ASSERT_CONFIG)
+      // this must come last - generate an error if we don't
+      // recognise the platform:
+#     error "Unknown platform - please configure and report the results to boost.org"
+#  endif
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+#  include "boost/config/platform/linux.hpp"
+#  include "boost/config/platform/bsd.hpp"
+#  include "boost/config/platform/solaris.hpp"
+#  include "boost/config/platform/irix.hpp"
+#  include "boost/config/platform/hpux.hpp"
+#  include "boost/config/platform/cygwin.hpp"
+#  include "boost/config/platform/win32.hpp"
+#  include "boost/config/platform/beos.hpp"
+#  include "boost/config/platform/macos.hpp"
+#  include "boost/config/platform/zos.hpp"
+#  include "boost/config/platform/aix.hpp"
+#  include "boost/config/platform/amigaos.hpp"
+#  include "boost/config/platform/qnxnto.hpp"
+#  include "boost/config/platform/vxworks.hpp"
+#  include "boost/config/platform/symbian.hpp" 
+#  include "boost/config/platform/cray.hpp" 
+#  include "boost/config/platform/vms.hpp" 
+#  include <boost/config/detail/posix_features.hpp>
+
+
+
+#endif
+
diff --git a/boost/config/detail/select_stdlib_config.hpp b/boost/config/detail/select_stdlib_config.hpp
new file mode 100644
index 0000000..8db778c
--- /dev/null
+++ b/boost/config/detail/select_stdlib_config.hpp
@@ -0,0 +1,110 @@
+//  Boost compiler configuration selection header file
+
+//  (C) Copyright John Maddock 2001 - 2003. 
+//  (C) Copyright Jens Maurer 2001 - 2002. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+//  See http://www.boost.org for most recent version.
+
+// locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed:
+
+// First include <cstddef> to determine if some version of STLport is in use as the std lib
+// (do not rely on this header being included since users can short-circuit this header 
+//  if they know whose std lib they are using.)
+#ifdef __cplusplus
+#  include <cstddef>
+#else
+#  include <stddef.h>
+#endif
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+// STLPort library; this _must_ come first, otherwise since
+// STLport typically sits on top of some other library, we
+// can end up detecting that first rather than STLport:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp"
+
+#else
+
+// If our std lib was not some version of STLport, and has not otherwise
+// been detected, then include <utility> as it is about 
+// the smallest of the std lib headers that includes real C++ stuff.
+// Some std libs do not include their C++-related macros in <cstddef> 
+// so this additional include makes sure we get those definitions.
+// Note: do not rely on this header being included since users can short-circuit this 
+// #include if they know whose std lib they are using.
+#if !defined(__LIBCOMO__) && !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER)\
+   && !defined(_LIBCPP_VERSION) && !defined(__GLIBCPP__) && !defined(__GLIBCXX__)\
+   && !defined(__STL_CONFIG_H) && !defined(__MSL_CPP__) && !defined(__IBMCPP__)\
+   && !defined(MSIPL_COMPILE_H) && !defined(_YVALS) && !defined(_CPPLIB_VER)
+#include <utility>
+#endif
+
+#if defined(__LIBCOMO__)
+// Comeau STL:
+#define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp"
+
+#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// Rogue Wave library:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp"
+
+#elif defined(_LIBCPP_VERSION)
+// libc++
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcpp.hpp"
+
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+// GNU libstdc++ 3
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp"
+
+#elif defined(__STL_CONFIG_H)
+// generic SGI STL
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp"
+
+#elif defined(__MSL_CPP__)
+// MSL standard lib:
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"
+
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
+// IBM z/OS XL C/C++
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/xlcpp_zos.hpp"
+
+#elif defined(__IBMCPP__)
+// take the default VACPP std lib
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"
+
+#elif defined(MSIPL_COMPILE_H)
+// Modena C++ standard library
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp"
+
+#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+// Dinkumware Library (this has to appear after any possible replacement libraries):
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp"
+
+#elif defined (BOOST_ASSERT_CONFIG)
+// this must come last - generate an error if we don't
+// recognise the library:
+#  error "Unknown standard library - please configure and report the results to boost.org"
+
+#endif
+
+#endif
+
+#if 0
+//
+// This section allows dependency scanners to find all the files we *might* include:
+//
+#  include "boost/config/stdlib/stlport.hpp"
+#  include "boost/config/stdlib/libcomo.hpp"
+#  include "boost/config/stdlib/roguewave.hpp"
+#  include "boost/config/stdlib/libcpp.hpp"
+#  include "boost/config/stdlib/libstdcpp3.hpp"
+#  include "boost/config/stdlib/sgi.hpp"
+#  include "boost/config/stdlib/msl.hpp"
+#  include "boost/config/stdlib/xlcpp_zos.hpp"
+#  include "boost/config/stdlib/vacpp.hpp"
+#  include "boost/config/stdlib/modena.hpp"
+#  include "boost/config/stdlib/dinkumware.hpp"
+#endif
+
diff --git a/boost/config/detail/suffix.hpp b/boost/config/detail/suffix.hpp
new file mode 100644
index 0000000..caa0b22
--- /dev/null
+++ b/boost/config/detail/suffix.hpp
@@ -0,0 +1,1046 @@
+//  Boost config.hpp configuration header file  ------------------------------//
+//  boostinspect:ndprecated_macros -- tell the inspect tool to ignore this file
+
+//  Copyright (c) 2001-2003 John Maddock
+//  Copyright (c) 2001 Darin Adler
+//  Copyright (c) 2001 Peter Dimov
+//  Copyright (c) 2002 Bill Kempf
+//  Copyright (c) 2002 Jens Maurer
+//  Copyright (c) 2002-2003 David Abrahams
+//  Copyright (c) 2003 Gennaro Prota
+//  Copyright (c) 2003 Eric Friedman
+//  Copyright (c) 2010 Eric Jourdanneau, Joel Falcou
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org/ for most recent version.
+
+//  Boost config.hpp policy and rationale documentation has been moved to
+//  http://www.boost.org/libs/config/
+//
+//  This file is intended to be stable, and relatively unchanging.
+//  It should contain boilerplate code only - no compiler specific
+//  code unless it is unavoidable - no changes unless unavoidable.
+
+#ifndef BOOST_CONFIG_SUFFIX_HPP
+#define BOOST_CONFIG_SUFFIX_HPP
+
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+//
+// Some GCC-4.x versions issue warnings even when __extension__ is used,
+// so use this as a workaround:
+//
+#pragma GCC system_header
+#endif
+
+//
+// ensure that visibility macros are always defined, thus symplifying use
+//
+#ifndef BOOST_SYMBOL_EXPORT
+# define BOOST_SYMBOL_EXPORT
+#endif
+#ifndef BOOST_SYMBOL_IMPORT
+# define BOOST_SYMBOL_IMPORT
+#endif
+#ifndef BOOST_SYMBOL_VISIBLE
+# define BOOST_SYMBOL_VISIBLE
+#endif
+
+//
+// look for long long by looking for the appropriate macros in <limits.h>.
+// Note that we use limits.h rather than climits for maximal portability,
+// remember that since these just declare a bunch of macros, there should be
+// no namespace issues from this.
+//
+#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG)                                              \
+   && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
+# include <limits.h>
+# if (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
+#   define BOOST_HAS_LONG_LONG
+# else
+#   define BOOST_NO_LONG_LONG
+# endif
+#endif
+
+// GCC 3.x will clean up all of those nasty macro definitions that
+// BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine
+// it under GCC 3.x.
+#if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS)
+#  undef BOOST_NO_CTYPE_FUNCTIONS
+#endif
+
+//
+// Assume any extensions are in namespace std:: unless stated otherwise:
+//
+#  ifndef BOOST_STD_EXTENSION_NAMESPACE
+#    define BOOST_STD_EXTENSION_NAMESPACE std
+#  endif
+
+//
+// If cv-qualified specializations are not allowed, then neither are cv-void ones:
+//
+#  if defined(BOOST_NO_CV_SPECIALIZATIONS) \
+      && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+#     define BOOST_NO_CV_VOID_SPECIALIZATIONS
+#  endif
+
+//
+// If there is no numeric_limits template, then it can't have any compile time
+// constants either!
+//
+#  if defined(BOOST_NO_LIMITS) \
+      && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
+#     define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+#     define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#     define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+#  endif
+
+//
+// if there is no long long then there is no specialisation
+// for numeric_limits<long long> either:
+//
+#if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)
+#  define BOOST_NO_LONG_LONG_NUMERIC_LIMITS
+#endif
+
+//
+// if there is no __int64 then there is no specialisation
+// for numeric_limits<__int64> either:
+//
+#if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)
+#  define BOOST_NO_MS_INT64_NUMERIC_LIMITS
+#endif
+
+//
+// if member templates are supported then so is the
+// VC6 subset of member templates:
+//
+#  if !defined(BOOST_NO_MEMBER_TEMPLATES) \
+       && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#     define BOOST_MSVC6_MEMBER_TEMPLATES
+#  endif
+
+//
+// Without partial specialization, can't test for partial specialisation bugs:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)
+#     define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
+#  endif
+
+//
+// Without partial specialization, we can't have array-type partial specialisations:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
+#     define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
+#  endif
+
+//
+// Without partial specialization, std::iterator_traits can't work:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+#     define BOOST_NO_STD_ITERATOR_TRAITS
+#  endif
+
+//
+// Without partial specialization, partial
+// specialization with default args won't work either:
+//
+#  if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+      && !defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+#     define BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
+#  endif
+
+//
+// Without member template support, we can't have template constructors
+// in the standard library either:
+//
+#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
+      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
+      && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
+#     define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
+#  endif
+
+//
+// Without member template support, we can't have a conforming
+// std::allocator template either:
+//
+#  if defined(BOOST_NO_MEMBER_TEMPLATES) \
+      && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \
+      && !defined(BOOST_NO_STD_ALLOCATOR)
+#     define BOOST_NO_STD_ALLOCATOR
+#  endif
+
+//
+// without ADL support then using declarations will break ADL as well:
+//
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL)
+#  define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
+#endif
+
+//
+// Without typeid support we have no dynamic RTTI either:
+//
+#if defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
+#  define BOOST_NO_RTTI
+#endif
+
+//
+// If we have a standard allocator, then we have a partial one as well:
+//
+#if !defined(BOOST_NO_STD_ALLOCATOR)
+#  define BOOST_HAS_PARTIAL_STD_ALLOCATOR
+#endif
+
+//
+// We can't have a working std::use_facet if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET)
+#     define BOOST_NO_STD_USE_FACET
+#  endif
+
+//
+// We can't have a std::messages facet if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES)
+#     define BOOST_NO_STD_MESSAGES
+#  endif
+
+//
+// We can't have a working std::wstreambuf if there is no std::locale:
+//
+#  if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
+#     define BOOST_NO_STD_WSTREAMBUF
+#  endif
+
+//
+// We can't have a <cwctype> if there is no <cwchar>:
+//
+#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE)
+#     define BOOST_NO_CWCTYPE
+#  endif
+
+//
+// We can't have a swprintf if there is no <cwchar>:
+//
+#  if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF)
+#     define BOOST_NO_SWPRINTF
+#  endif
+
+//
+// If Win32 support is turned off, then we must turn off
+// threading support also, unless there is some other
+// thread API enabled:
+//
+#if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \
+   && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS)
+#  define BOOST_DISABLE_THREADS
+#endif
+
+//
+// Turn on threading support if the compiler thinks that it's in
+// multithreaded mode.  We put this here because there are only a
+// limited number of macros that identify this (if there's any missing
+// from here then add to the appropriate compiler section):
+//
+#if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \
+    || defined(_PTHREADS) || defined(__APPLE__) || defined(__DragonFly__)) \
+    && !defined(BOOST_HAS_THREADS)
+#  define BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading support off if BOOST_DISABLE_THREADS is defined:
+//
+#if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS)
+#  undef BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading support off if we don't recognise the threading API:
+//
+#if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\
+      && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\
+      && !defined(BOOST_HAS_MPTASKS)
+#  undef BOOST_HAS_THREADS
+#endif
+
+//
+// Turn threading detail macros off if we don't (want to) use threading
+//
+#ifndef BOOST_HAS_THREADS
+#  undef BOOST_HAS_PTHREADS
+#  undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  undef BOOST_HAS_PTHREAD_YIELD
+#  undef BOOST_HAS_PTHREAD_DELAY_NP
+#  undef BOOST_HAS_WINTHREADS
+#  undef BOOST_HAS_BETHREADS
+#  undef BOOST_HAS_MPTASKS
+#endif
+
+//
+// If the compiler claims to be C99 conformant, then it had better
+// have a <stdint.h>:
+//
+#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
+#     define BOOST_HAS_STDINT_H
+#     ifndef BOOST_HAS_LOG1P
+#        define BOOST_HAS_LOG1P
+#     endif
+#     ifndef BOOST_HAS_EXPM1
+#        define BOOST_HAS_EXPM1
+#     endif
+#  endif
+
+//
+// Define BOOST_NO_SLIST and BOOST_NO_HASH if required.
+// Note that this is for backwards compatibility only.
+//
+#  if !defined(BOOST_HAS_SLIST) && !defined(BOOST_NO_SLIST)
+#     define BOOST_NO_SLIST
+#  endif
+
+#  if !defined(BOOST_HAS_HASH) && !defined(BOOST_NO_HASH)
+#     define BOOST_NO_HASH
+#  endif
+
+//
+// Set BOOST_SLIST_HEADER if not set already:
+//
+#if defined(BOOST_HAS_SLIST) && !defined(BOOST_SLIST_HEADER)
+#  define BOOST_SLIST_HEADER <slist>
+#endif
+
+//
+// Set BOOST_HASH_SET_HEADER if not set already:
+//
+#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_SET_HEADER)
+#  define BOOST_HASH_SET_HEADER <hash_set>
+#endif
+
+//
+// Set BOOST_HASH_MAP_HEADER if not set already:
+//
+#if defined(BOOST_HAS_HASH) && !defined(BOOST_HASH_MAP_HEADER)
+#  define BOOST_HASH_MAP_HEADER <hash_map>
+#endif
+
+//  BOOST_HAS_ABI_HEADERS
+//  This macro gets set if we have headers that fix the ABI,
+//  and prevent ODR violations when linking to external libraries:
+#if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS)
+#  define BOOST_HAS_ABI_HEADERS
+#endif
+
+#if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS)
+#  undef BOOST_HAS_ABI_HEADERS
+#endif
+
+//  BOOST_NO_STDC_NAMESPACE workaround  --------------------------------------//
+//  Because std::size_t usage is so common, even in boost headers which do not
+//  otherwise use the C library, the <cstddef> workaround is included here so
+//  that ugly workaround code need not appear in many other boost headers.
+//  NOTE WELL: This is a workaround for non-conforming compilers; <cstddef>
+//  must still be #included in the usual places so that <cstddef> inclusion
+//  works as expected with standard conforming compilers.  The resulting
+//  double inclusion of <cstddef> is harmless.
+
+# if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus)
+#   include <cstddef>
+    namespace std { using ::ptrdiff_t; using ::size_t; }
+# endif
+
+//  Workaround for the unfortunate min/max macros defined by some platform headers
+
+#define BOOST_PREVENT_MACRO_SUBSTITUTION
+
+#ifndef BOOST_USING_STD_MIN
+#  define BOOST_USING_STD_MIN() using std::min
+#endif
+
+#ifndef BOOST_USING_STD_MAX
+#  define BOOST_USING_STD_MAX() using std::max
+#endif
+
+//  BOOST_NO_STD_MIN_MAX workaround  -----------------------------------------//
+
+#  if defined(BOOST_NO_STD_MIN_MAX) && defined(__cplusplus)
+
+namespace std {
+  template <class _Tp>
+  inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
+    return __b < __a ? __b : __a;
+  }
+  template <class _Tp>
+  inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) {
+    return  __a < __b ? __b : __a;
+  }
+}
+
+#  endif
+
+// BOOST_STATIC_CONSTANT workaround --------------------------------------- //
+// On compilers which don't allow in-class initialization of static integral
+// constant members, we must use enums as a workaround if we want the constants
+// to be available at compile-time. This macro gives us a convenient way to
+// declare such constants.
+
+#  ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
+#       define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment }
+#  else
+#     define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment
+#  endif
+
+// BOOST_USE_FACET / HAS_FACET workaround ----------------------------------//
+// When the standard library does not have a conforming std::use_facet there
+// are various workarounds available, but they differ from library to library.
+// The same problem occurs with has_facet.
+// These macros provide a consistent way to access a locale's facets.
+// Usage:
+//    replace
+//       std::use_facet<Type>(loc);
+//    with
+//       BOOST_USE_FACET(Type, loc);
+//    Note do not add a std:: prefix to the front of BOOST_USE_FACET!
+//  Use for BOOST_HAS_FACET is analogous.
+
+#if defined(BOOST_NO_STD_USE_FACET)
+#  ifdef BOOST_HAS_TWO_ARG_USE_FACET
+#     define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast<Type*>(0))
+#     define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast<Type*>(0))
+#  elif defined(BOOST_HAS_MACRO_USE_FACET)
+#     define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type)
+#     define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type)
+#  elif defined(BOOST_HAS_STLP_USE_FACET)
+#     define BOOST_USE_FACET(Type, loc) (*std::_Use_facet<Type >(loc))
+#     define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
+#  endif
+#else
+#  define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc)
+#  define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc)
+#endif
+
+// BOOST_NESTED_TEMPLATE workaround ------------------------------------------//
+// Member templates are supported by some compilers even though they can't use
+// the A::template member<U> syntax, as a workaround replace:
+//
+// typedef typename A::template rebind<U> binder;
+//
+// with:
+//
+// typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
+#  define BOOST_NESTED_TEMPLATE template
+#else
+#  define BOOST_NESTED_TEMPLATE
+#endif
+
+// BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------//
+// Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION
+// is defined, in which case it evaluates to return x; Use when you have a return
+// statement that can never be reached.
+
+#ifndef BOOST_UNREACHABLE_RETURN
+#  ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION
+#     define BOOST_UNREACHABLE_RETURN(x) return x;
+#  else
+#     define BOOST_UNREACHABLE_RETURN(x)
+#  endif
+#endif
+
+// BOOST_DEDUCED_TYPENAME workaround ------------------------------------------//
+//
+// Some compilers don't support the use of `typename' for dependent
+// types in deduced contexts, e.g.
+//
+//     template <class T> void f(T, typename T::type);
+//                                  ^^^^^^^^
+// Replace these declarations with:
+//
+//     template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);
+
+#ifndef BOOST_NO_DEDUCED_TYPENAME
+#  define BOOST_DEDUCED_TYPENAME typename
+#else
+#  define BOOST_DEDUCED_TYPENAME
+#endif
+
+#ifndef BOOST_NO_TYPENAME_WITH_CTOR
+#  define BOOST_CTOR_TYPENAME typename
+#else
+#  define BOOST_CTOR_TYPENAME
+#endif
+
+// long long workaround ------------------------------------------//
+// On gcc (and maybe other compilers?) long long is alway supported
+// but it's use may generate either warnings (with -ansi), or errors
+// (with -pedantic -ansi) unless it's use is prefixed by __extension__
+//
+#if defined(BOOST_HAS_LONG_LONG) && defined(__cplusplus)
+namespace boost{
+#  ifdef __GNUC__
+   __extension__ typedef long long long_long_type;
+   __extension__ typedef unsigned long long ulong_long_type;
+#  else
+   typedef long long long_long_type;
+   typedef unsigned long long ulong_long_type;
+#  endif
+}
+#endif
+// same again for __int128:
+#if defined(BOOST_HAS_INT128) && defined(__cplusplus)
+namespace boost{
+#  ifdef __GNUC__
+   __extension__ typedef __int128 int128_type;
+   __extension__ typedef unsigned __int128 uint128_type;
+#  else
+   typedef __int128 int128_type;
+   typedef unsigned __int128 uint128_type;
+#  endif
+}
+#endif
+// same again for __float128:
+#if defined(BOOST_HAS_FLOAT128) && defined(__cplusplus)
+namespace boost {
+#  ifdef __GNUC__
+   __extension__ typedef __float128 float128_type;
+#  else
+   typedef __float128 float128_type;
+#  endif
+}
+#endif
+
+// BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------//
+
+// These macros are obsolete. Port away and remove.
+
+#  define BOOST_EXPLICIT_TEMPLATE_TYPE(t)
+#  define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
+#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
+#  define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
+
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v)
+#  define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v)
+
+// When BOOST_NO_STD_TYPEINFO is defined, we can just import
+// the global definition into std namespace:
+#if defined(BOOST_NO_STD_TYPEINFO) && defined(__cplusplus)
+#include <typeinfo>
+namespace std{ using ::type_info; }
+#endif
+
+// ---------------------------------------------------------------------------//
+
+//
+// Helper macro BOOST_STRINGIZE:
+// Converts the parameter X to a string after macro replacement
+// on X has been performed.
+//
+#define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X)
+#define BOOST_DO_STRINGIZE(X) #X
+
+//
+// Helper macro BOOST_JOIN:
+// The following piece of macro magic joins the two
+// arguments together, even when one of the arguments is
+// itself a macro (see 16.3.1 in C++ standard).  The key
+// is that macro expansion of macro arguments does not
+// occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN.
+//
+#define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y )
+#define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y)
+#define BOOST_DO_JOIN2( X, Y ) X##Y
+
+//
+// Set some default values for compiler/library/platform names.
+// These are for debugging config setup only:
+//
+#  ifndef BOOST_COMPILER
+#     define BOOST_COMPILER "Unknown ISO C++ Compiler"
+#  endif
+#  ifndef BOOST_STDLIB
+#     define BOOST_STDLIB "Unknown ISO standard library"
+#  endif
+#  ifndef BOOST_PLATFORM
+#     if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \
+         || defined(_POSIX_SOURCE)
+#        define BOOST_PLATFORM "Generic Unix"
+#     else
+#        define BOOST_PLATFORM "Unknown"
+#     endif
+#  endif
+
+//
+// Set some default values GPU support
+//
+#  ifndef BOOST_GPU_ENABLED
+#  define BOOST_GPU_ENABLED
+#  endif
+
+// BOOST_RESTRICT ---------------------------------------------//
+// Macro to use in place of 'restrict' keyword variants
+#if !defined(BOOST_RESTRICT)
+#  if defined(_MSC_VER)
+#    define BOOST_RESTRICT __restrict
+#    if !defined(BOOST_NO_RESTRICT_REFERENCES) && (_MSC_FULL_VER < 190023026)
+#      define BOOST_NO_RESTRICT_REFERENCES
+#    endif
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    define BOOST_RESTRICT __restrict__
+#  else
+#    define BOOST_RESTRICT
+#    if !defined(BOOST_NO_RESTRICT_REFERENCES)
+#      define BOOST_NO_RESTRICT_REFERENCES
+#    endif
+#  endif
+#endif
+
+// BOOST_MAY_ALIAS -----------------------------------------------//
+// The macro expands to an attribute to mark a type that is allowed to alias other types.
+// The macro is defined in the compiler-specific headers.
+#if !defined(BOOST_MAY_ALIAS)
+#  define BOOST_NO_MAY_ALIAS
+#  define BOOST_MAY_ALIAS
+#endif
+
+// BOOST_FORCEINLINE ---------------------------------------------//
+// Macro to use in place of 'inline' to force a function to be inline
+#if !defined(BOOST_FORCEINLINE)
+#  if defined(_MSC_VER)
+#    define BOOST_FORCEINLINE __forceinline
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+#  else
+#    define BOOST_FORCEINLINE inline
+#  endif
+#endif
+
+// BOOST_NOINLINE ---------------------------------------------//
+// Macro to use in place of 'inline' to prevent a function to be inlined
+#if !defined(BOOST_NOINLINE)
+#  if defined(_MSC_VER)
+#    define BOOST_NOINLINE __declspec(noinline)
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    if defined(__CUDACC__)
+       // nvcc doesn't always parse __noinline__,
+       // see: https://svn.boost.org/trac/boost/ticket/9392
+#      define BOOST_NOINLINE __attribute__ ((noinline))
+#    else
+#      define BOOST_NOINLINE __attribute__ ((__noinline__))
+#    endif
+#  else
+#    define BOOST_NOINLINE
+#  endif
+#endif
+
+// BOOST_NORETURN ---------------------------------------------//
+// Macro to use before a function declaration/definition to designate
+// the function as not returning normally (i.e. with a return statement
+// or by leaving the function scope, if the function return type is void).
+#if !defined(BOOST_NORETURN)
+#  if defined(_MSC_VER)
+#    define BOOST_NORETURN __declspec(noreturn)
+#  elif defined(__GNUC__)
+#    define BOOST_NORETURN __attribute__ ((__noreturn__))
+#  elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
+#    if __has_attribute(noreturn)
+#      define BOOST_NORETURN [[noreturn]]
+#    endif
+#  elif defined(__has_cpp_attribute) 
+#    if __has_cpp_attribute(noreturn)
+#      define BOOST_NORETURN [[noreturn]]
+#    endif
+#  endif
+#endif
+
+#if !defined(BOOST_NORETURN)
+#  define BOOST_NO_NORETURN
+#  define BOOST_NORETURN
+#endif
+
+// Branch prediction hints
+// These macros are intended to wrap conditional expressions that yield true or false
+//
+//  if (BOOST_LIKELY(var == 10))
+//  {
+//     // the most probable code here
+//  }
+//
+#if !defined(BOOST_LIKELY)
+#  define BOOST_LIKELY(x) x
+#endif
+#if !defined(BOOST_UNLIKELY)
+#  define BOOST_UNLIKELY(x) x
+#endif
+
+// Type and data alignment specification
+//
+#if !defined(BOOST_ALIGNMENT)
+#  if !defined(BOOST_NO_CXX11_ALIGNAS)
+#    define BOOST_ALIGNMENT(x) alignas(x)
+#  elif defined(_MSC_VER)
+#    define BOOST_ALIGNMENT(x) __declspec(align(x))
+#  elif defined(__GNUC__)
+#    define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x)))
+#  else
+#    define BOOST_NO_ALIGNMENT
+#    define BOOST_ALIGNMENT(x)
+#  endif
+#endif
+
+// Lack of non-public defaulted functions is implied by the lack of any defaulted functions
+#if !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS) && defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
+// Defaulted and deleted function declaration helpers
+// These macros are intended to be inside a class definition.
+// BOOST_DEFAULTED_FUNCTION accepts the function declaration and its
+// body, which will be used if the compiler doesn't support defaulted functions.
+// BOOST_DELETED_FUNCTION only accepts the function declaration. It
+// will expand to a private function declaration, if the compiler doesn't support
+// deleted functions. Because of this it is recommended to use BOOST_DELETED_FUNCTION
+// in the end of the class definition.
+//
+//  class my_class
+//  {
+//  public:
+//      // Default-constructible
+//      BOOST_DEFAULTED_FUNCTION(my_class(), {})
+//      // Copying prohibited
+//      BOOST_DELETED_FUNCTION(my_class(my_class const&))
+//      BOOST_DELETED_FUNCTION(my_class& operator= (my_class const&))
+//  };
+//
+#if !(defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS))
+#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun = default;
+#else
+#   define BOOST_DEFAULTED_FUNCTION(fun, body) fun body
+#endif
+
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#   define BOOST_DELETED_FUNCTION(fun) fun = delete;
+#else
+#   define BOOST_DELETED_FUNCTION(fun) private: fun;
+#endif
+
+//
+// Set BOOST_NO_DECLTYPE_N3276 when BOOST_NO_DECLTYPE is defined
+//
+#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#define BOOST_NO_CXX11_DECLTYPE_N3276 BOOST_NO_CXX11_DECLTYPE
+#endif
+
+//  -------------------- Deprecated macros for 1.50 ---------------------------
+//  These will go away in a future release
+
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET or BOOST_NO_CXX11_HDR_UNORDERED_MAP
+//           instead of BOOST_NO_STD_UNORDERED
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) || defined (BOOST_NO_CXX11_HDR_UNORDERED_SET)
+# ifndef BOOST_NO_CXX11_STD_UNORDERED
+#  define BOOST_NO_CXX11_STD_UNORDERED
+# endif
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST instead of BOOST_NO_INITIALIZER_LISTS
+#if defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_INITIALIZER_LISTS)
+#  define BOOST_NO_INITIALIZER_LISTS
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_ARRAY instead of BOOST_NO_0X_HDR_ARRAY
+#if defined(BOOST_NO_CXX11_HDR_ARRAY) && !defined(BOOST_NO_0X_HDR_ARRAY)
+#  define BOOST_NO_0X_HDR_ARRAY
+#endif
+//  Use BOOST_NO_CXX11_HDR_CHRONO instead of BOOST_NO_0X_HDR_CHRONO
+#if defined(BOOST_NO_CXX11_HDR_CHRONO) && !defined(BOOST_NO_0X_HDR_CHRONO)
+#  define BOOST_NO_0X_HDR_CHRONO
+#endif
+//  Use BOOST_NO_CXX11_HDR_CODECVT instead of BOOST_NO_0X_HDR_CODECVT
+#if defined(BOOST_NO_CXX11_HDR_CODECVT) && !defined(BOOST_NO_0X_HDR_CODECVT)
+#  define BOOST_NO_0X_HDR_CODECVT
+#endif
+//  Use BOOST_NO_CXX11_HDR_CONDITION_VARIABLE instead of BOOST_NO_0X_HDR_CONDITION_VARIABLE
+#if defined(BOOST_NO_CXX11_HDR_CONDITION_VARIABLE) && !defined(BOOST_NO_0X_HDR_CONDITION_VARIABLE)
+#  define BOOST_NO_0X_HDR_CONDITION_VARIABLE
+#endif
+//  Use BOOST_NO_CXX11_HDR_FORWARD_LIST instead of BOOST_NO_0X_HDR_FORWARD_LIST
+#if defined(BOOST_NO_CXX11_HDR_FORWARD_LIST) && !defined(BOOST_NO_0X_HDR_FORWARD_LIST)
+#  define BOOST_NO_0X_HDR_FORWARD_LIST
+#endif
+//  Use BOOST_NO_CXX11_HDR_FUTURE instead of BOOST_NO_0X_HDR_FUTURE
+#if defined(BOOST_NO_CXX11_HDR_FUTURE) && !defined(BOOST_NO_0X_HDR_FUTURE)
+#  define BOOST_NO_0X_HDR_FUTURE
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+//  instead of BOOST_NO_0X_HDR_INITIALIZER_LIST or BOOST_NO_INITIALIZER_LISTS
+#ifdef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+# ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST
+#  define BOOST_NO_0X_HDR_INITIALIZER_LIST
+# endif
+# ifndef BOOST_NO_INITIALIZER_LISTS
+#  define BOOST_NO_INITIALIZER_LISTS
+# endif
+#endif
+
+//  Use BOOST_NO_CXX11_HDR_MUTEX instead of BOOST_NO_0X_HDR_MUTEX
+#if defined(BOOST_NO_CXX11_HDR_MUTEX) && !defined(BOOST_NO_0X_HDR_MUTEX)
+#  define BOOST_NO_0X_HDR_MUTEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_RANDOM instead of BOOST_NO_0X_HDR_RANDOM
+#if defined(BOOST_NO_CXX11_HDR_RANDOM) && !defined(BOOST_NO_0X_HDR_RANDOM)
+#  define BOOST_NO_0X_HDR_RANDOM
+#endif
+//  Use BOOST_NO_CXX11_HDR_RATIO instead of BOOST_NO_0X_HDR_RATIO
+#if defined(BOOST_NO_CXX11_HDR_RATIO) && !defined(BOOST_NO_0X_HDR_RATIO)
+#  define BOOST_NO_0X_HDR_RATIO
+#endif
+//  Use BOOST_NO_CXX11_HDR_REGEX instead of BOOST_NO_0X_HDR_REGEX
+#if defined(BOOST_NO_CXX11_HDR_REGEX) && !defined(BOOST_NO_0X_HDR_REGEX)
+#  define BOOST_NO_0X_HDR_REGEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_SYSTEM_ERROR instead of BOOST_NO_0X_HDR_SYSTEM_ERROR
+#if defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR) && !defined(BOOST_NO_0X_HDR_SYSTEM_ERROR)
+#  define BOOST_NO_0X_HDR_SYSTEM_ERROR
+#endif
+//  Use BOOST_NO_CXX11_HDR_THREAD instead of BOOST_NO_0X_HDR_THREAD
+#if defined(BOOST_NO_CXX11_HDR_THREAD) && !defined(BOOST_NO_0X_HDR_THREAD)
+#  define BOOST_NO_0X_HDR_THREAD
+#endif
+//  Use BOOST_NO_CXX11_HDR_TUPLE instead of BOOST_NO_0X_HDR_TUPLE
+#if defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_0X_HDR_TUPLE)
+#  define BOOST_NO_0X_HDR_TUPLE
+#endif
+//  Use BOOST_NO_CXX11_HDR_TYPE_TRAITS instead of BOOST_NO_0X_HDR_TYPE_TRAITS
+#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_0X_HDR_TYPE_TRAITS)
+#  define BOOST_NO_0X_HDR_TYPE_TRAITS
+#endif
+//  Use BOOST_NO_CXX11_HDR_TYPEINDEX instead of BOOST_NO_0X_HDR_TYPEINDEX
+#if defined(BOOST_NO_CXX11_HDR_TYPEINDEX) && !defined(BOOST_NO_0X_HDR_TYPEINDEX)
+#  define BOOST_NO_0X_HDR_TYPEINDEX
+#endif
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_MAP instead of BOOST_NO_0X_HDR_UNORDERED_MAP
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_MAP) && !defined(BOOST_NO_0X_HDR_UNORDERED_MAP)
+#  define BOOST_NO_0X_HDR_UNORDERED_MAP
+#endif
+//  Use BOOST_NO_CXX11_HDR_UNORDERED_SET instead of BOOST_NO_0X_HDR_UNORDERED_SET
+#if defined(BOOST_NO_CXX11_HDR_UNORDERED_SET) && !defined(BOOST_NO_0X_HDR_UNORDERED_SET)
+#  define BOOST_NO_0X_HDR_UNORDERED_SET
+#endif
+
+//  ------------------ End of deprecated macros for 1.50 ---------------------------
+
+//  -------------------- Deprecated macros for 1.51 ---------------------------
+//  These will go away in a future release
+
+//  Use     BOOST_NO_CXX11_AUTO_DECLARATIONS instead of   BOOST_NO_AUTO_DECLARATIONS
+#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_AUTO_DECLARATIONS)
+#  define BOOST_NO_AUTO_DECLARATIONS
+#endif
+//  Use     BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS instead of   BOOST_NO_AUTO_MULTIDECLARATIONS
+#if defined(BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS) && !defined(BOOST_NO_AUTO_MULTIDECLARATIONS)
+#  define BOOST_NO_AUTO_MULTIDECLARATIONS
+#endif
+//  Use     BOOST_NO_CXX11_CHAR16_T instead of   BOOST_NO_CHAR16_T
+#if defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CHAR16_T)
+#  define BOOST_NO_CHAR16_T
+#endif
+//  Use     BOOST_NO_CXX11_CHAR32_T instead of   BOOST_NO_CHAR32_T
+#if defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CHAR32_T)
+#  define BOOST_NO_CHAR32_T
+#endif
+//  Use     BOOST_NO_CXX11_TEMPLATE_ALIASES instead of   BOOST_NO_TEMPLATE_ALIASES
+#if defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && !defined(BOOST_NO_TEMPLATE_ALIASES)
+#  define BOOST_NO_TEMPLATE_ALIASES
+#endif
+//  Use     BOOST_NO_CXX11_CONSTEXPR instead of   BOOST_NO_CONSTEXPR
+#if defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CONSTEXPR)
+#  define BOOST_NO_CONSTEXPR
+#endif
+//  Use     BOOST_NO_CXX11_DECLTYPE_N3276 instead of   BOOST_NO_DECLTYPE_N3276
+#if defined(BOOST_NO_CXX11_DECLTYPE_N3276) && !defined(BOOST_NO_DECLTYPE_N3276)
+#  define BOOST_NO_DECLTYPE_N3276
+#endif
+//  Use     BOOST_NO_CXX11_DECLTYPE instead of   BOOST_NO_DECLTYPE
+#if defined(BOOST_NO_CXX11_DECLTYPE) && !defined(BOOST_NO_DECLTYPE)
+#  define BOOST_NO_DECLTYPE
+#endif
+//  Use     BOOST_NO_CXX11_DEFAULTED_FUNCTIONS instead of   BOOST_NO_DEFAULTED_FUNCTIONS
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_DEFAULTED_FUNCTIONS)
+#  define BOOST_NO_DEFAULTED_FUNCTIONS
+#endif
+//  Use     BOOST_NO_CXX11_DELETED_FUNCTIONS instead of   BOOST_NO_DELETED_FUNCTIONS
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS) && !defined(BOOST_NO_DELETED_FUNCTIONS)
+#  define BOOST_NO_DELETED_FUNCTIONS
+#endif
+//  Use     BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS instead of   BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) && !defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS)
+#  define BOOST_NO_EXPLICIT_CONVERSION_OPERATORS
+#endif
+//  Use     BOOST_NO_CXX11_EXTERN_TEMPLATE instead of   BOOST_NO_EXTERN_TEMPLATE
+#if defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) && !defined(BOOST_NO_EXTERN_TEMPLATE)
+#  define BOOST_NO_EXTERN_TEMPLATE
+#endif
+//  Use     BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS instead of   BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !defined(BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+#  define BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+//  Use     BOOST_NO_CXX11_LAMBDAS instead of   BOOST_NO_LAMBDAS
+#if defined(BOOST_NO_CXX11_LAMBDAS) && !defined(BOOST_NO_LAMBDAS)
+#  define BOOST_NO_LAMBDAS
+#endif
+//  Use     BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS instead of   BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#if defined(BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS) && !defined(BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS)
+#  define BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS
+#endif
+//  Use     BOOST_NO_CXX11_NOEXCEPT instead of   BOOST_NO_NOEXCEPT
+#if defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_NOEXCEPT)
+#  define BOOST_NO_NOEXCEPT
+#endif
+//  Use     BOOST_NO_CXX11_NULLPTR instead of   BOOST_NO_NULLPTR
+#if defined(BOOST_NO_CXX11_NULLPTR) && !defined(BOOST_NO_NULLPTR)
+#  define BOOST_NO_NULLPTR
+#endif
+//  Use     BOOST_NO_CXX11_RAW_LITERALS instead of   BOOST_NO_RAW_LITERALS
+#if defined(BOOST_NO_CXX11_RAW_LITERALS) && !defined(BOOST_NO_RAW_LITERALS)
+#  define BOOST_NO_RAW_LITERALS
+#endif
+//  Use     BOOST_NO_CXX11_RVALUE_REFERENCES instead of   BOOST_NO_RVALUE_REFERENCES
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_RVALUE_REFERENCES)
+#  define BOOST_NO_RVALUE_REFERENCES
+#endif
+//  Use     BOOST_NO_CXX11_SCOPED_ENUMS instead of   BOOST_NO_SCOPED_ENUMS
+#if defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_NO_SCOPED_ENUMS)
+#  define BOOST_NO_SCOPED_ENUMS
+#endif
+//  Use     BOOST_NO_CXX11_STATIC_ASSERT instead of   BOOST_NO_STATIC_ASSERT
+#if defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_NO_STATIC_ASSERT)
+#  define BOOST_NO_STATIC_ASSERT
+#endif
+//  Use     BOOST_NO_CXX11_STD_UNORDERED instead of   BOOST_NO_STD_UNORDERED
+#if defined(BOOST_NO_CXX11_STD_UNORDERED) && !defined(BOOST_NO_STD_UNORDERED)
+#  define BOOST_NO_STD_UNORDERED
+#endif
+//  Use     BOOST_NO_CXX11_UNICODE_LITERALS instead of   BOOST_NO_UNICODE_LITERALS
+#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(BOOST_NO_UNICODE_LITERALS)
+#  define BOOST_NO_UNICODE_LITERALS
+#endif
+//  Use     BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX instead of   BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
+#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX)
+#  define BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX
+#endif
+//  Use     BOOST_NO_CXX11_VARIADIC_TEMPLATES instead of   BOOST_NO_VARIADIC_TEMPLATES
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
+#  define BOOST_NO_VARIADIC_TEMPLATES
+#endif
+//  Use     BOOST_NO_CXX11_VARIADIC_MACROS instead of   BOOST_NO_VARIADIC_MACROS
+#if defined(BOOST_NO_CXX11_VARIADIC_MACROS) && !defined(BOOST_NO_VARIADIC_MACROS)
+#  define BOOST_NO_VARIADIC_MACROS
+#endif
+//  Use     BOOST_NO_CXX11_NUMERIC_LIMITS instead of   BOOST_NO_NUMERIC_LIMITS_LOWEST
+#if defined(BOOST_NO_CXX11_NUMERIC_LIMITS) && !defined(BOOST_NO_NUMERIC_LIMITS_LOWEST)
+#  define BOOST_NO_NUMERIC_LIMITS_LOWEST
+#endif
+//  ------------------ End of deprecated macros for 1.51 ---------------------------
+
+
+
+//
+// Helper macros BOOST_NOEXCEPT, BOOST_NOEXCEPT_IF, BOOST_NOEXCEPT_EXPR
+// These aid the transition to C++11 while still supporting C++03 compilers
+//
+#ifdef BOOST_NO_CXX11_NOEXCEPT
+#  define BOOST_NOEXCEPT
+#  define BOOST_NOEXCEPT_OR_NOTHROW throw()
+#  define BOOST_NOEXCEPT_IF(Predicate)
+#  define BOOST_NOEXCEPT_EXPR(Expression) false
+#else
+#  define BOOST_NOEXCEPT noexcept
+#  define BOOST_NOEXCEPT_OR_NOTHROW noexcept
+#  define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
+#  define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
+#endif
+//
+// Helper macro BOOST_FALLTHROUGH
+// Fallback definition of BOOST_FALLTHROUGH macro used to mark intended
+// fall-through between case labels in a switch statement. We use a definition
+// that requires a semicolon after it to avoid at least one type of misuse even
+// on unsupported compilers.
+//
+#ifndef BOOST_FALLTHROUGH
+#  define BOOST_FALLTHROUGH ((void)0)
+#endif
+
+//
+// constexpr workarounds
+//
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#define BOOST_CONSTEXPR
+#define BOOST_CONSTEXPR_OR_CONST const
+#else
+#define BOOST_CONSTEXPR constexpr
+#define BOOST_CONSTEXPR_OR_CONST constexpr
+#endif
+#if defined(BOOST_NO_CXX14_CONSTEXPR)
+#define BOOST_CXX14_CONSTEXPR
+#else
+#define BOOST_CXX14_CONSTEXPR constexpr
+#endif
+
+//
+// Unused variable/typedef workarounds:
+//
+#ifndef BOOST_ATTRIBUTE_UNUSED
+#  define BOOST_ATTRIBUTE_UNUSED
+#endif
+
+#define BOOST_STATIC_CONSTEXPR  static BOOST_CONSTEXPR_OR_CONST
+
+//
+// Set BOOST_HAS_STATIC_ASSERT when BOOST_NO_CXX11_STATIC_ASSERT is not defined
+//
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) && !defined(BOOST_HAS_STATIC_ASSERT)
+#  define BOOST_HAS_STATIC_ASSERT
+#endif
+
+//
+// Set BOOST_HAS_RVALUE_REFS when BOOST_NO_CXX11_RVALUE_REFERENCES is not defined
+//
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_HAS_RVALUE_REFS)
+#define BOOST_HAS_RVALUE_REFS
+#endif
+
+//
+// Set BOOST_HAS_VARIADIC_TMPL when BOOST_NO_CXX11_VARIADIC_TEMPLATES is not defined
+//
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_HAS_VARIADIC_TMPL)
+#define BOOST_HAS_VARIADIC_TMPL
+#endif
+//
+// Set BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS when
+// BOOST_NO_CXX11_VARIADIC_TEMPLATES is set:
+//
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS)
+#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#endif
+
+//
+// Finish off with checks for macros that are depricated / no longer supported,
+// if any of these are set then it's very likely that much of Boost will no
+// longer work.  So stop with a #error for now, but give the user a chance
+// to continue at their own risk if they really want to:
+//
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_CONFIG_ALLOW_DEPRECATED)
+#  error "You are using a compiler which lacks features which are now a minimum requirement in order to use Boost, define BOOST_CONFIG_ALLOW_DEPRECATED if you want to continue at your own risk!!!"
+#endif
+
+#endif
diff --git a/boost/config/platform/aix.hpp b/boost/config/platform/aix.hpp
index 894ef42..a48e232 100644
--- a/boost/config/platform/aix.hpp
+++ b/boost/config/platform/aix.hpp
@@ -26,7 +26,7 @@
 //#define BOOST_HAS_PTHREAD_YIELD
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/boost/config/platform/beos.hpp b/boost/config/platform/beos.hpp
index 48c3d8d..6158c1c 100644
--- a/boost/config/platform/beos.hpp
+++ b/boost/config/platform/beos.hpp
@@ -20,7 +20,7 @@
 #endif
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
  
 
 
diff --git a/boost/config/platform/bsd.hpp b/boost/config/platform/bsd.hpp
index a014297..79e74a0 100644
--- a/boost/config/platform/bsd.hpp
+++ b/boost/config/platform/bsd.hpp
@@ -77,7 +77,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/boost/config/platform/cray.hpp b/boost/config/platform/cray.hpp
index 5c476e4..103e9c0 100644
--- a/boost/config/platform/cray.hpp
+++ b/boost/config/platform/cray.hpp
@@ -12,7 +12,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/boost/config/platform/cygwin.hpp b/boost/config/platform/cygwin.hpp
index 53e23f7..8ecc4a4 100644
--- a/boost/config/platform/cygwin.hpp
+++ b/boost/config/platform/cygwin.hpp
@@ -43,7 +43,7 @@
 #define BOOST_NO_FENV_H
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 //
 // Cygwin lies about XSI conformance, there is no nl_types.h:
diff --git a/boost/config/platform/haiku.hpp b/boost/config/platform/haiku.hpp
index 750866c..04244c5 100644
--- a/boost/config/platform/haiku.hpp
+++ b/boost/config/platform/haiku.hpp
@@ -28,4 +28,4 @@
 #define BOOST_HAS_GETTIMEOFDAY
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
diff --git a/boost/config/platform/hpux.hpp b/boost/config/platform/hpux.hpp
index 19ce68e..222622e 100644
--- a/boost/config/platform/hpux.hpp
+++ b/boost/config/platform/hpux.hpp
@@ -43,7 +43,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // the following are always available:
 #ifndef BOOST_HAS_GETTIMEOFDAY
diff --git a/boost/config/platform/irix.hpp b/boost/config/platform/irix.hpp
index aeae49c..0acb651 100644
--- a/boost/config/platform/irix.hpp
+++ b/boost/config/platform/irix.hpp
@@ -25,7 +25,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/boost/config/platform/linux.hpp b/boost/config/platform/linux.hpp
index 8c43c7b..c4eef8f 100644
--- a/boost/config/platform/linux.hpp
+++ b/boost/config/platform/linux.hpp
@@ -24,8 +24,9 @@
 #if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1)))
    // <stdint.h> defines int64_t unconditionally, but <sys/types.h> defines
    // int64_t only if __GNUC__.  Thus, assume a fully usable <stdint.h>
-   // only when using GCC.
-#  if defined __GNUC__
+   // only when using GCC.  Update 2017: this appears not to be the case for
+   // recent glibc releases, see bug report: https://svn.boost.org/trac/boost/ticket/13045
+#  if defined(__GNUC__) || ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 5)))
 #    define BOOST_HAS_STDINT_H
 #  endif
 #endif
@@ -71,7 +72,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 #if defined(__USE_GNU) && !defined(__ANDROID__) && !defined(ANDROID)
 #define BOOST_HAS_PTHREAD_YIELD
 #endif
diff --git a/boost/config/platform/macos.hpp b/boost/config/platform/macos.hpp
index 5be4e3b..ed7dc15 100644
--- a/boost/config/platform/macos.hpp
+++ b/boost/config/platform/macos.hpp
@@ -25,7 +25,7 @@
 // to replace the platform-native BSD one. G++ users
 // should also always be able to do this on MaxOS X.
 //
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 #  ifndef BOOST_HAS_STDINT_H
 #     define BOOST_HAS_STDINT_H
 #  endif
diff --git a/boost/config/platform/qnxnto.hpp b/boost/config/platform/qnxnto.hpp
index b1377c8..d0298cb 100644
--- a/boost/config/platform/qnxnto.hpp
+++ b/boost/config/platform/qnxnto.hpp
@@ -10,7 +10,7 @@
 #define BOOST_PLATFORM "QNX"
 
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h
 // or log1p and expm1:
diff --git a/boost/config/platform/solaris.hpp b/boost/config/platform/solaris.hpp
index 6e4efc9..51ffe67 100644
--- a/boost/config/platform/solaris.hpp
+++ b/boost/config/platform/solaris.hpp
@@ -14,7 +14,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 //
 // pthreads don't actually work with gcc unless _PTHREADS is defined:
diff --git a/boost/config/platform/symbian.hpp b/boost/config/platform/symbian.hpp
index e02a778..f814d00 100644
--- a/boost/config/platform/symbian.hpp
+++ b/boost/config/platform/symbian.hpp
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #endif// boilerplate code:
 #  define BOOST_HAS_UNISTD_H
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 // S60 SDK defines _POSIX_VERSION as POSIX.1
 #  ifndef BOOST_HAS_STDINT_H
 #    define BOOST_HAS_STDINT_H
diff --git a/boost/config/platform/vxworks.hpp b/boost/config/platform/vxworks.hpp
index cdda015..a7f571c 100644
--- a/boost/config/platform/vxworks.hpp
+++ b/boost/config/platform/vxworks.hpp
@@ -180,7 +180,7 @@
   // Luckily, at the moment there seems to be none!
 #endif
 
-// These #defines allow posix_features to work, since vxWorks doesn't
+// These #defines allow detail/posix_features to work, since vxWorks doesn't
 // #define them itself for DKMs (for RTPs on the contrary it does):
 #ifdef _WRS_KERNEL
 #  ifndef _POSIX_TIMERS
@@ -286,10 +286,8 @@ inline ssize_t readlink(const char*, char*, size_t){
   return -1;
 }
 
-// vxWorks claims to implement gettimeofday in sys/time.h
-// but nevertheless does not provide it! See
-// https://support.windriver.com/olsPortal/faces/maintenance/techtipDetail_noHeader.jspx?docId=16442&contentId=WR_TECHTIP_006256
-// We implement a surrogate version here via clock_gettime:
+#if (_WRS_VXWORKS_MAJOR < 7)
+
 inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -297,6 +295,8 @@ inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
   tv->tv_usec = ts.tv_nsec / 1000;
   return 0;
 }
+#endif
+
 
 // vxWorks does provide neither struct tms nor function times()!
 // We implement an empty dummy-function, simply setting the user
@@ -327,6 +327,7 @@ inline clock_t times(struct tms *t){
   return ticks;
 }
 
+extern void 	bzero	    (void *, size_t);    // FD_ZERO uses bzero() but doesn't include strings.h
 } // extern "C"
 
 // Put the selfmade functions into the std-namespace, just in case
@@ -349,21 +350,43 @@ namespace std {
 // Include signal.h which might contain a typo to be corrected here
 #include <signal.h>
 
-#define getpagesize()    sysconf(_SC_PAGESIZE)         // getpagesize is deprecated anyway!
+inline int getpagesize() { return sysconf(_SC_PAGESIZE); }         // getpagesize is deprecated anyway!
 #ifndef S_ISSOCK
 #  define S_ISSOCK(mode) ((mode & S_IFMT) == S_IFSOCK) // Is file a socket?
 #endif
-#define lstat(p, b)      stat(p, b)                    // lstat() == stat(), as vxWorks has no symlinks!
+inline int lstat(p, b) { return stat(p, b); }  // lstat() == stat(), as vxWorks has no symlinks!
 #ifndef FPE_FLTINV
 #  define FPE_FLTINV     (FPE_FLTSUB+1)                // vxWorks has no FPE_FLTINV, so define one as a dummy
 #endif
 #if !defined(BUS_ADRALN) && defined(BUS_ADRALNR)
 #  define BUS_ADRALN     BUS_ADRALNR                   // Correct a supposed typo in vxWorks' <signal.h>
 #endif
-//typedef int              locale_t;                     // locale_t is a POSIX-extension, currently unpresent in vxWorks!
+typedef int              locale_t;                     // locale_t is a POSIX-extension, currently not present in vxWorks!
 
 // #include boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // vxWorks lies about XSI conformance, there is no nl_types.h:
 #undef BOOST_HAS_NL_TYPES_H
+
+// vxWorks 7 adds C++11 support 
+// however it is optional, and does not match exactly the support determined
+// by examining Dinkum STL version and GCC version (or ICC and DCC) 
+
+#ifndef _WRS_CONFIG_LANG_LIB_CPLUS_CPLUS_USER_2011
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX 
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TUPLE 
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_SMART_PTR 
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET 
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL 
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#else
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+
diff --git a/boost/config/platform/zos.hpp b/boost/config/platform/zos.hpp
new file mode 100644
index 0000000..fa77999
--- /dev/null
+++ b/boost/config/platform/zos.hpp
@@ -0,0 +1,32 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org for most recent version.
+
+//  Platform setup for IBM z/OS.
+
+#define BOOST_PLATFORM "IBM z/OS"
+
+#include <features.h> // For __UU, __C99, __TR1, ...
+
+#if defined(__UU)
+#  define BOOST_HAS_GETTIMEOFDAY
+#endif
+
+#if defined(_OPEN_THREADS) || defined(__SUSV3_THR)
+#  define BOOST_HAS_PTHREADS
+#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  define BOOST_HAS_THREADS
+#endif
+
+#if defined(__SUSV3) || defined(__SUSV3_THR)
+#  define BOOST_HAS_SCHED_YIELD
+#endif
+
+#define BOOST_HAS_SIGACTION
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_NL_TYPES_H
diff --git a/boost/config/stdlib/dinkumware.hpp b/boost/config/stdlib/dinkumware.hpp
index 3b95dcf..0af104d 100644
--- a/boost/config/stdlib/dinkumware.hpp
+++ b/boost/config/stdlib/dinkumware.hpp
@@ -147,6 +147,13 @@
 #  define BOOST_NO_CXX11_STD_ALIGN
 #endif
 
+// Before 650 std::pointer_traits has a broken rebind template
+#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 650
+#  define BOOST_NO_CXX11_POINTER_TRAITS
+#elif defined(BOOST_MSVC) && BOOST_MSVC < 1910
+#  define BOOST_NO_CXX11_POINTER_TRAITS
+#endif
+
 #if defined(__has_include)
 #if !__has_include(<shared_mutex>)
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
@@ -163,9 +170,12 @@
 #endif
 
 // C++17 features
+#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1910) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0)
 #  define BOOST_NO_CXX17_STD_APPLY
+#endif
 #if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 #endif
 
 #if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400)
@@ -188,11 +198,14 @@
 #endif
 
 #if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 650)
-// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr is not available.
+// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr and std::random_shuffle are not available.
 // See https://www.visualstudio.com/en-us/news/vs2015-vs.aspx#C++
 // and http://blogs.msdn.com/b/vcblog/archive/2015/06/19/c-11-14-17-features-in-vs-2015-rtm.aspx
 #  if defined(_HAS_AUTO_PTR_ETC) && (_HAS_AUTO_PTR_ETC == 0)
 #    define BOOST_NO_AUTO_PTR
+#    define BOOST_NO_CXX98_RANDOM_SHUFFLE
+#    define BOOST_NO_CXX98_FUNCTION_BASE
+#    define BOOST_NO_CXX98_BINDERS
 #  endif
 #endif
 
diff --git a/boost/config/stdlib/libcomo.hpp b/boost/config/stdlib/libcomo.hpp
index e3fc627..75ac2bb 100644
--- a/boost/config/stdlib/libcomo.hpp
+++ b/boost/config/stdlib/libcomo.hpp
@@ -55,6 +55,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -78,6 +79,7 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 //
 // Intrinsic type_traits support.
diff --git a/boost/config/stdlib/libcpp.hpp b/boost/config/stdlib/libcpp.hpp
index 2eea999..3d3f4ae 100644
--- a/boost/config/stdlib/libcpp.hpp
+++ b/boost/config/stdlib/libcpp.hpp
@@ -29,6 +29,7 @@
 // aliases since members rebind_alloc and rebind_traits require it.
 #if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES)
 #    define BOOST_NO_CXX11_ALLOCATOR
+#    define BOOST_NO_CXX11_POINTER_TRAITS
 #endif
 
 #if __cplusplus < 201103
@@ -53,6 +54,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
 #  define BOOST_NO_CXX11_STD_ALIGN
@@ -91,6 +93,17 @@
 #if (_LIBCPP_VERSION < 4000) || (__cplusplus <= 201402L)
 #  define BOOST_NO_CXX17_STD_APPLY
 #endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+#  define BOOST_NO_AUTO_PTR
+#endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE)
+#  define BOOST_NO_CXX98_RANDOM_SHUFFLE
+#endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
+#  define BOOST_NO_CXX98_BINDERS
+#endif
+
+#define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #if (_LIBCPP_VERSION <= 1101) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
 // This is a bit of a sledgehammer, because really it's just libc++abi that has no
diff --git a/boost/config/stdlib/libstdcpp3.hpp b/boost/config/stdlib/libstdcpp3.hpp
index 205489a..6cd420a 100644
--- a/boost/config/stdlib/libstdcpp3.hpp
+++ b/boost/config/stdlib/libstdcpp3.hpp
@@ -143,6 +143,37 @@
 #  define BOOST_LIBSTDCXX_VERSION 40300
 #endif
 
+#if (BOOST_LIBSTDCXX_VERSION < 50100)
+// libstdc++ does not define this function as it's deprecated in C++11, but clang still looks for it,
+// defining it here is a terrible cludge, but should get things working:
+extern "C" char *gets (char *__s);
+#endif
+//
+// clang is unable to parse some GCC headers, add those workarounds here:
+//
+#if BOOST_LIBSTDCXX_VERSION < 50000
+#  define BOOST_NO_CXX11_HDR_REGEX
+#endif
+//
+// GCC 4.7.x has no __cxa_thread_atexit which
+// thread_local objects require for cleanup:
+//
+#if BOOST_LIBSTDCXX_VERSION < 40800
+#  define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+//
+// Early clang versions can handle <chrono>, not exactly sure which versions
+// but certainly up to clang-3.8 and gcc-4.6:
+//
+#if (__clang_major__ < 5)
+#  if BOOST_LIBSTDCXX_VERSION < 40800
+#     define BOOST_NO_CXX11_HDR_FUTURE
+#     define BOOST_NO_CXX11_HDR_MUTEX
+#     define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#     define BOOST_NO_CXX11_HDR_CHRONO
+#  endif
+#endif
+
 //
 //  GCC 4.8 and 9 add working versions of <atomic> and <regex> respectively.
 //  However, we have no test for these as the headers were present but broken
@@ -216,6 +247,7 @@
 #if (BOOST_LIBSTDCXX_VERSION < 40600) || !defined(BOOST_LIBSTDCXX11)
 #  define BOOST_NO_CXX11_HDR_TYPEINDEX
 #  define BOOST_NO_CXX11_ADDRESSOF
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 #endif
 
 //  C++0x features in GCC 4.7.0 and later
@@ -225,6 +257,7 @@
 // so 4.7.0 is the first truly conforming one.
 #  define BOOST_NO_CXX11_HDR_CHRONO
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #endif
 //  C++0x features in GCC 4.8.0 and later
 //
diff --git a/boost/config/stdlib/modena.hpp b/boost/config/stdlib/modena.hpp
index fa4a818..81919e0 100644
--- a/boost/config/stdlib/modena.hpp
+++ b/boost/config/stdlib/modena.hpp
@@ -44,6 +44,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -67,6 +68,7 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #define BOOST_STDLIB "Modena C++ standard library"
 
diff --git a/boost/config/stdlib/msl.hpp b/boost/config/stdlib/msl.hpp
index 8f21a13..0e2e2af 100644
--- a/boost/config/stdlib/msl.hpp
+++ b/boost/config/stdlib/msl.hpp
@@ -34,7 +34,7 @@
 #    define BOOST_HAS_UNISTD_H
 #  endif
    // boilerplate code:
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 #endif
 
 #if defined(_MWMT) || _MSL_THREADSAFE
@@ -68,6 +68,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -91,5 +92,6 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
diff --git a/boost/config/stdlib/roguewave.hpp b/boost/config/stdlib/roguewave.hpp
index 437d38d..df60215 100644
--- a/boost/config/stdlib/roguewave.hpp
+++ b/boost/config/stdlib/roguewave.hpp
@@ -180,6 +180,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -203,3 +204,4 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
diff --git a/boost/config/stdlib/sgi.hpp b/boost/config/stdlib/sgi.hpp
index 8d2f849..0c8ab2e 100644
--- a/boost/config/stdlib/sgi.hpp
+++ b/boost/config/stdlib/sgi.hpp
@@ -138,6 +138,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -161,5 +162,6 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #define BOOST_STDLIB "SGI standard library"
diff --git a/boost/config/stdlib/stlport.hpp b/boost/config/stdlib/stlport.hpp
index 518f9ef..2e304e2 100644
--- a/boost/config/stdlib/stlport.hpp
+++ b/boost/config/stdlib/stlport.hpp
@@ -228,6 +228,7 @@ namespace boost { using std::min; using std::max; }
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -251,5 +252,6 @@ namespace boost { using std::min; using std::max; }
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
diff --git a/boost/config/stdlib/vacpp.hpp b/boost/config/stdlib/vacpp.hpp
index f9afef6..c4e1fb1 100644
--- a/boost/config/stdlib/vacpp.hpp
+++ b/boost/config/stdlib/vacpp.hpp
@@ -44,6 +44,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -67,5 +68,6 @@
 // C++17 features
 #  define BOOST_NO_CXX17_STD_APPLY
 #  define BOOST_NO_CXX17_STD_INVOKE
+#  define BOOST_NO_CXX17_ITERATOR_TRAITS
 
 #define BOOST_STDLIB "Visual Age default standard library"
diff --git a/boost/config/stdlib/xlcpp_zos.hpp b/boost/config/stdlib/xlcpp_zos.hpp
new file mode 100644
index 0000000..4d5beb1
--- /dev/null
+++ b/boost/config/stdlib/xlcpp_zos.hpp
@@ -0,0 +1,60 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+//  See http://www.boost.org for most recent version.
+
+//  Standard library setup for IBM z/OS XL C/C++ compiler.
+
+// Oldest library version currently supported is 2.1 (V2R1)
+#if __TARGET_LIB__ < 0x42010000
+#  error "Library version not supported or configured - please reconfigure"
+#endif
+
+#if __TARGET_LIB__ > 0x42010000
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown library version - please run the configure tests and report the results"
+#  endif
+#endif
+
+#define BOOST_STDLIB "IBM z/OS XL C/C++ standard library"
+
+#define BOOST_HAS_MACRO_USE_FACET
+
+#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+#define BOOST_NO_CXX11_ADDRESSOF
+#define BOOST_NO_CXX11_SMART_PTR
+#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#define BOOST_NO_CXX11_NUMERIC_LIMITS
+#define BOOST_NO_CXX11_ALLOCATOR
+#define BOOST_NO_CXX11_POINTER_TRAITS
+#define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#define BOOST_NO_CXX11_HDR_TYPEINDEX
+#define BOOST_NO_CXX11_HDR_TUPLE
+#define BOOST_NO_CXX11_HDR_THREAD
+#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#define BOOST_NO_CXX11_HDR_REGEX
+#define BOOST_NO_CXX11_HDR_RATIO
+#define BOOST_NO_CXX11_HDR_RANDOM
+#define BOOST_NO_CXX11_HDR_MUTEX
+#define BOOST_NO_CXX11_HDR_FUTURE
+#define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#define BOOST_NO_CXX11_HDR_CODECVT
+#define BOOST_NO_CXX11_HDR_CHRONO
+#define BOOST_NO_CXX11_HDR_ATOMIC
+#define BOOST_NO_CXX11_HDR_ARRAY
+#define BOOST_NO_CXX11_STD_ALIGN
+
+#define BOOST_NO_CXX14_STD_EXCHANGE
+#define BOOST_NO_CXX14_HDR_SHARED_MUTEX
+
+#define BOOST_NO_CXX17_STD_INVOKE
+#define BOOST_NO_CXX17_STD_APPLY
+#define BOOST_NO_CXX17_ITERATOR_TRAITS
diff --git a/boost/config/workaround.hpp b/boost/config/workaround.hpp
new file mode 100644
index 0000000..0ce8108
--- /dev/null
+++ b/boost/config/workaround.hpp
@@ -0,0 +1,277 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef BOOST_CONFIG_WORKAROUND_HPP
+#define BOOST_CONFIG_WORKAROUND_HPP
+
+// Compiler/library version workaround macro
+//
+// Usage:
+//
+//   #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+//      // workaround for eVC4 and VC6
+//      ... // workaround code here
+//   #endif
+//
+// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
+// first argument must be undefined or expand to a numeric
+// value. The above expands to:
+//
+//   (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
+//
+// When used for workarounds that apply to the latest known version
+// and all earlier versions of a compiler, the following convention
+// should be observed:
+//
+//   #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
+//
+// The version number in this case corresponds to the last version in
+// which the workaround was known to have been required. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
+// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
+// the workaround for any version of the compiler. When
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
+// error will be issued if the compiler version exceeds the argument
+// to BOOST_TESTED_AT().  This can be used to locate workarounds which
+// may be obsoleted by newer versions.
+
+#ifndef BOOST_STRICT_CONFIG
+
+#include <boost/config.hpp>
+
+#ifndef __BORLANDC__
+#define __BORLANDC___WORKAROUND_GUARD 1
+#else
+#define __BORLANDC___WORKAROUND_GUARD 0
+#endif
+#ifndef __CODEGEARC__
+#define __CODEGEARC___WORKAROUND_GUARD 1
+#else
+#define __CODEGEARC___WORKAROUND_GUARD 0
+#endif
+#ifndef _MSC_VER
+#define _MSC_VER_WORKAROUND_GUARD 1
+#else
+#define _MSC_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef _MSC_FULL_VER
+#define _MSC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define _MSC_FULL_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_MSVC
+#define BOOST_MSVC_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_MSVC_FULL_VER
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC__
+#define __GNUC___WORKAROUND_GUARD 1
+#else
+#define __GNUC___WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC_MINOR__
+#define __GNUC_MINOR___WORKAROUND_GUARD 1
+#else
+#define __GNUC_MINOR___WORKAROUND_GUARD 0
+#endif
+#ifndef __GNUC_PATCHLEVEL__
+#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
+#else
+#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_GCC
+#define BOOST_GCC_WORKAROUND_GUARD 1
+#else
+#define BOOST_GCC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_XLCPP_ZOS
+#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 1
+#else
+#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 0
+#endif
+#ifndef __IBMCPP__
+#define __IBMCPP___WORKAROUND_GUARD 1
+#else
+#define __IBMCPP___WORKAROUND_GUARD 0
+#endif
+#ifndef __SUNPRO_CC
+#define __SUNPRO_CC_WORKAROUND_GUARD 1
+#else
+#define __SUNPRO_CC_WORKAROUND_GUARD 0
+#endif
+#ifndef __DECCXX_VER
+#define __DECCXX_VER_WORKAROUND_GUARD 1
+#else
+#define __DECCXX_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __MWERKS__
+#define __MWERKS___WORKAROUND_GUARD 1
+#else
+#define __MWERKS___WORKAROUND_GUARD 0
+#endif
+#ifndef __EDG__
+#define __EDG___WORKAROUND_GUARD 1
+#else
+#define __EDG___WORKAROUND_GUARD 0
+#endif
+#ifndef __EDG_VERSION__
+#define __EDG_VERSION___WORKAROUND_GUARD 1
+#else
+#define __EDG_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef __HP_aCC
+#define __HP_aCC_WORKAROUND_GUARD 1
+#else
+#define __HP_aCC_WORKAROUND_GUARD 0
+#endif
+#ifndef __hpxstd98
+#define __hpxstd98_WORKAROUND_GUARD 1
+#else
+#define __hpxstd98_WORKAROUND_GUARD 0
+#endif
+#ifndef _CRAYC
+#define _CRAYC_WORKAROUND_GUARD 1
+#else
+#define _CRAYC_WORKAROUND_GUARD 0
+#endif
+#ifndef __DMC__
+#define __DMC___WORKAROUND_GUARD 1
+#else
+#define __DMC___WORKAROUND_GUARD 0
+#endif
+#ifndef MPW_CPLUS
+#define MPW_CPLUS_WORKAROUND_GUARD 1
+#else
+#define MPW_CPLUS_WORKAROUND_GUARD 0
+#endif
+#ifndef __COMO__
+#define __COMO___WORKAROUND_GUARD 1
+#else
+#define __COMO___WORKAROUND_GUARD 0
+#endif
+#ifndef __COMO_VERSION__
+#define __COMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __COMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef __INTEL_COMPILER
+#define __INTEL_COMPILER_WORKAROUND_GUARD 1
+#else
+#define __INTEL_COMPILER_WORKAROUND_GUARD 0
+#endif
+#ifndef __ICL
+#define __ICL_WORKAROUND_GUARD 1
+#else
+#define __ICL_WORKAROUND_GUARD 0
+#endif
+#ifndef _COMPILER_VERSION
+#define _COMPILER_VERSION_WORKAROUND_GUARD 1
+#else
+#define _COMPILER_VERSION_WORKAROUND_GUARD 0
+#endif
+
+#ifndef _RWSTD_VER
+#define _RWSTD_VER_WORKAROUND_GUARD 1
+#else
+#define _RWSTD_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_RWSTD_VER
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
+#endif
+#ifndef __GLIBCPP__
+#define __GLIBCPP___WORKAROUND_GUARD 1
+#else
+#define __GLIBCPP___WORKAROUND_GUARD 0
+#endif
+#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
+#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
+#else
+#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
+#endif
+#ifndef __SGI_STL_PORT
+#define __SGI_STL_PORT_WORKAROUND_GUARD 1
+#else
+#define __SGI_STL_PORT_WORKAROUND_GUARD 0
+#endif
+#ifndef _STLPORT_VERSION
+#define _STLPORT_VERSION_WORKAROUND_GUARD 1
+#else
+#define _STLPORT_VERSION_WORKAROUND_GUARD 0
+#endif
+#ifndef __LIBCOMO_VERSION__
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
+#else
+#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
+#endif
+#ifndef _CPPLIB_VER
+#define _CPPLIB_VER_WORKAROUND_GUARD 1
+#else
+#define _CPPLIB_VER_WORKAROUND_GUARD 0
+#endif
+
+#ifndef BOOST_INTEL_CXX_VERSION
+#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_INTEL_WIN
+#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_DINKUMWARE_STDLIB
+#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
+#else
+#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_INTEL
+#define BOOST_INTEL_WORKAROUND_GUARD 1
+#else
+#define BOOST_INTEL_WORKAROUND_GUARD 0
+#endif
+// Always define to zero, if it's used it'll be defined my MPL:
+#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
+
+#define BOOST_WORKAROUND(symbol, test)                \
+       ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
+       (symbol != 0) && (1 % (( (symbol test) ) + 1)))
+//                              ^ ^           ^ ^
+// The extra level of parenthesis nesting above, along with the
+// BOOST_OPEN_PAREN indirection below, is required to satisfy the
+// broken preprocessor in MWCW 8.3 and earlier.
+//
+// The basic mechanism works as follows:
+//   (symbol test) + 1        =>   if (symbol test) then 2 else 1
+//   1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
+//
+// The complication with % is for cooperation with BOOST_TESTED_AT().
+// When "test" is BOOST_TESTED_AT(x) and
+// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
+//
+//   symbol test              =>   if (symbol <= x) then 1 else -1
+//   (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
+//   1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
+//
+
+#ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
+#  define BOOST_OPEN_PAREN (
+#  define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
+#else
+#  define BOOST_TESTED_AT(value) != ((value)-(value))
+#endif
+
+#else
+
+#define BOOST_WORKAROUND(symbol, test) 0
+
+#endif
+
+#endif // BOOST_CONFIG_WORKAROUND_HPP
diff --git a/boost/container/allocator_traits.hpp b/boost/container/allocator_traits.hpp
index d6621f6..b08f601 100644
--- a/boost/container/allocator_traits.hpp
+++ b/boost/container/allocator_traits.hpp
@@ -347,7 +347,7 @@ struct allocator_traits
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
-      //! otherwise, invokes <code>::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
+      //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
       template <class T, class ...Args>
       BOOST_CONTAINER_FORCEINLINE static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
diff --git a/boost/container/detail/advanced_insert_int.hpp b/boost/container/detail/advanced_insert_int.hpp
index 1050857..db5e8df 100644
--- a/boost/container/detail/advanced_insert_int.hpp
+++ b/boost/container/detail/advanced_insert_int.hpp
@@ -31,7 +31,7 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
@@ -157,13 +157,13 @@ struct insert_copy_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), v_);
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
-      *p =v_;
+      *p = v_;
    }
 
    const value_type &v_;
@@ -184,7 +184,7 @@ struct insert_move_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::move(v_) );
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
@@ -240,7 +240,7 @@ struct insert_nonmovable_emplace_proxy
    void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
    {
       BOOST_ASSERT(n == 1); (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
    }
 
    protected:
@@ -354,7 +354,7 @@ struct insert_nonmovable_emplace_proxy##N\
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
-      alloc_traits::construct(a, iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
+      alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
    void copy_n_and_update(Allocator &, Iterator, size_type)\
diff --git a/boost/container/detail/algorithm.hpp b/boost/container/detail/algorithm.hpp
index 67e7876..1184422 100644
--- a/boost/container/detail/algorithm.hpp
+++ b/boost/container/detail/algorithm.hpp
@@ -29,6 +29,128 @@ namespace container {
 using boost::intrusive::algo_equal;
 using boost::intrusive::algo_lexicographical_compare;
 
+template<class Func>
+class binder1st
+{
+   public:
+	typedef typename Func::second_argument_type  argument_type;
+	typedef typename Func::result_type           result_type;
+
+	binder1st(const Func& func, const typename Func::first_argument_type& arg)
+   	: op(func), value(arg)
+	{}
+
+	result_type operator()(const argument_type& arg) const
+   {	return op(value, arg);  }
+
+	result_type operator()(argument_type& arg) const
+   {  return op(value, arg);   }
+
+   private:
+	Func op;
+	typename Func::first_argument_type value;
+};
+
+template<class Func, class T> 
+inline binder1st<Func> bind1st(const Func& func, const T& arg)
+{	return boost::container::binder1st<Func>(func, arg);  }
+
+template<class Func>
+class binder2nd
+{
+   public:
+	typedef typename Func::first_argument_type   argument_type;
+	typedef typename Func::result_type           result_type;
+
+	binder2nd(const Func& func, const typename Func::second_argument_type& arg)
+	   : op(func), value(arg)
+   {}
+
+	result_type operator()(const argument_type& arg) const
+   {  return op(arg, value);  }
+
+	result_type operator()(argument_type& arg) const
+	{  return op(arg, value);  }
+
+   private:
+	Func op;
+	typename Func::second_argument_type value;
+};
+
+template<class Func, class T>
+inline binder2nd<Func> bind2nd(const Func& func, const T& arg)
+{
+   return (boost::container::binder2nd<Func>(func, arg));
+}
+
+template<class Func>
+class unary_negate
+{
+   public:
+   typedef typename Func::argument_type   argument_type;
+   typedef typename Func::result_type     result_type;
+
+	explicit unary_negate(const Func& func)
+		: m_func(func)
+   {}
+
+	bool operator()(const typename Func::argument_type& arg) const
+	{  return !m_func(arg);  }
+
+   private:
+	Func m_func;
+};
+
+template<class Func> inline
+unary_negate<Func> not1(const Func& func)
+{
+   return boost::container::unary_negate<Func>(func);
+}
+
+template<class InputIt, class UnaryPredicate>
+InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
+{
+   for (; first != last; ++first) {
+      if (p(*first)) {
+         return first;
+      }
+   }
+   return last;
+}
+
+template<class InputIt, class ForwardIt, class BinaryPredicate>
+InputIt find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2, BinaryPredicate p)
+{
+   for (; first1 != last1; ++first1) {
+      for (ForwardIt it = first2; it != last2; ++it) {
+         if (p(*first1, *it)) {
+            return first1;
+         }
+      }
+   }
+   return last1;
+}
+
+template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
+ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
+                        ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p)
+{
+   for (; ; ++first1) {
+      ForwardIt1 it = first1;
+      for (ForwardIt2 it2 = first2; ; ++it, ++it2) {
+         if (it2 == last2) {
+            return first1;
+         }
+         if (it == last1) {
+            return last1;
+         }
+         if (!p(*it, *it2)) {
+            break;
+         }
+      }
+   }
+}
+
 }  //namespace container {
 }  //namespace boost {
 
diff --git a/boost/container/detail/container_or_allocator_rebind.hpp b/boost/container/detail/container_or_allocator_rebind.hpp
new file mode 100644
index 0000000..c60d1c0
--- /dev/null
+++ b/boost/container/detail/container_or_allocator_rebind.hpp
@@ -0,0 +1,49 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP
+#define BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/allocator_traits.hpp>
+#include <boost/container/detail/container_rebind.hpp>
+#include <boost/container/detail/is_container.hpp>
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+template<class AllocatorOrContainer, class ToType, bool = is_container<AllocatorOrContainer>::value>
+struct container_or_allocator_rebind_impl
+   : container_rebind<AllocatorOrContainer, ToType>
+{};
+
+template<class AllocatorOrContainer, class ToType>
+struct container_or_allocator_rebind_impl<AllocatorOrContainer, ToType, false>
+   : allocator_traits<AllocatorOrContainer>::template portable_rebind_alloc<ToType>
+
+{};
+
+template<class AllocatorOrContainer, class ToType>
+struct container_or_allocator_rebind
+   : container_or_allocator_rebind_impl<AllocatorOrContainer, ToType>
+{};
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_OR_ALLOCATOR_REBIND_HPP
diff --git a/boost/container/detail/container_rebind.hpp b/boost/container/detail/container_rebind.hpp
new file mode 100644
index 0000000..79ad9d7
--- /dev/null
+++ b/boost/container/detail/container_rebind.hpp
@@ -0,0 +1,258 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_REBIND_HPP
+#define BOOST_CONTAINER_DETAIL_CONTAINER_REBIND_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/allocator_traits.hpp>
+
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+   template <class Cont, class U>
+   struct container_rebind;
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   template <template <class, class, class...> class Cont, typename V, typename A, class... An, class U>
+   struct container_rebind<Cont<V, A, An...>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
+   };
+
+   //Needed for non-conforming compilers like GCC 4.3
+   template <template <class, class> class Cont, typename V, typename A, class U>
+   struct container_rebind<Cont<V, A>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+   };
+
+   template <template <class> class Cont, typename V, class U>
+   struct container_rebind<Cont<V>, U>
+   {
+      typedef Cont<U> type;
+   };
+
+   //for small_vector,static_vector
+
+   template <template <class, std::size_t, class, class...> class Cont, typename V, std::size_t N, typename A, class... An, class U>
+   struct container_rebind<Cont<V, N, A, An...>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, An...> type;
+   };
+
+   //Needed for non-conforming compilers like GCC 4.3
+   template <template <class, std::size_t, class> class Cont, typename V, std::size_t N, typename A, class U>
+   struct container_rebind<Cont<V, N, A>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+   };
+
+   template <template <class, std::size_t> class Cont, typename V, std::size_t N, class U>
+   struct container_rebind<Cont<V, N>, U>
+   {
+      typedef Cont<U, N> type;
+   };
+
+#else //C++03 compilers
+
+   template <template <class> class Cont  //0arg
+      , typename V
+      , class U>
+      struct container_rebind<Cont<V>, U>
+   {
+      typedef Cont<U> type;
+   };
+
+   template <template <class, class> class Cont  //0arg
+      , typename V, typename A
+      , class U>
+      struct container_rebind<Cont<V, A>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+   };
+
+   template <template <class, class, class> class Cont  //1arg
+      , typename V, typename A, class P0
+      , class U>
+      struct container_rebind<Cont<V, A, P0>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0> type;
+   };
+
+   template <template <class, class, class, class> class Cont  //2arg
+      , typename V, typename A, class P0, class P1
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1> type;
+   };
+
+   template <template <class, class, class, class, class> class Cont  //3arg
+      , typename V, typename A, class P0, class P1, class P2
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
+   };
+
+   template <template <class, class, class, class, class, class> class Cont  //4arg
+      , typename V, typename A, class P0, class P1, class P2, class P3
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
+   };
+
+   template <template <class, class, class, class, class, class, class> class Cont  //5arg
+      , typename V, typename A, class P0, class P1, class P2, class P3, class P4
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
+   };
+
+   template <template <class, class, class, class, class, class, class, class> class Cont  //6arg
+      , typename V, typename A, class P0, class P1, class P2, class P3, class P4, class P5
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
+   };
+
+   template <template <class, class, class, class, class, class, class, class, class> class Cont  //7arg
+      , typename V, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
+   };
+
+   template <template <class, class, class, class, class, class, class, class, class, class> class Cont  //8arg
+      , typename V, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
+   };
+
+   template <template <class, class, class, class, class, class, class, class, class, class, class> class Cont  //9arg
+      , typename V, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8
+      , class U>
+      struct container_rebind<Cont<V, A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U>
+   {
+      typedef Cont<U, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
+   };
+
+   //For small_vector/static_vector
+   template <template <class, std::size_t> class Cont  //0arg
+      , typename V, std::size_t N
+      , class U>
+      struct container_rebind<Cont<V, N>, U>
+   {
+      typedef Cont<U, N> type;
+   };
+
+   template <template <class, std::size_t, class> class Cont  //0arg
+      , typename V, std::size_t N, typename A
+      , class U>
+      struct container_rebind<Cont<V, N, A>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type> type;
+   };
+
+   template <template <class, std::size_t, class, class> class Cont  //1arg
+      , typename V, std::size_t N, typename A, class P0
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0> type;
+   };
+
+   template <template <class, std::size_t, class, class, class> class Cont  //2arg
+      , typename V, std::size_t N, typename A, class P0, class P1
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class> class Cont  //3arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class> class Cont  //4arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class, class> class Cont  //5arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class, class, class> class Cont  //6arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class, class, class, class> class Cont  //7arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class, class, class, class, class> class Cont  //8arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6, P7>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7> type;
+   };
+
+   template <template <class, std::size_t, class, class, class, class, class, class, class, class, class, class> class Cont  //9arg
+      , typename V, std::size_t N, typename A, class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8
+      , class U>
+      struct container_rebind<Cont<V, N, A, P0, P1, P2, P3, P4, P5, P6, P7, P8>, U>
+   {
+      typedef Cont<U, N, typename allocator_traits<A>::template portable_rebind_alloc<U>::type, P0, P1, P2, P3, P4, P5, P6, P7, P8> type;
+   };
+
+#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_CONTAINER_REBIND_HPP
diff --git a/boost/container/detail/copy_move_algo.hpp b/boost/container/detail/copy_move_algo.hpp
index dda311a..5293260 100644
--- a/boost/container/detail/copy_move_algo.hpp
+++ b/boost/container/detail/copy_move_algo.hpp
@@ -22,7 +22,7 @@
 #include <boost/container/allocator_traits.hpp>
 // container/detail
 #include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/construct_in_place.hpp>
@@ -69,16 +69,12 @@ struct are_elements_contiguous< ::boost::move_iterator<It> >
 //    predeclarations
 /////////////////////////
 
-#ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 template<class Pointer>
 class vector_iterator;
 
 template<class Pointer>
 class vector_const_iterator;
 
-#endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 }  //namespace container_detail {
 }  //namespace container {
 
@@ -97,8 +93,6 @@ namespace container_detail {
 //vector_[const_]iterator
 /////////////////////////
 
-#ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 template<class Pointer>
 struct are_elements_contiguous<boost::container::container_detail::vector_iterator<Pointer> >
 {
@@ -111,8 +105,6 @@ struct are_elements_contiguous<boost::container::container_detail::vector_const_
    static const bool value = true;
 };
 
-#endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 /////////////////////////
 //    offset_ptr
 /////////////////////////
@@ -178,7 +170,7 @@ inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
    return r;
@@ -192,7 +184,7 @@ F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
    return r;
@@ -206,7 +198,7 @@ I memmove_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    if(n){
       typedef typename boost::container::iterator_traits<I>::value_type value_type;
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
    }
    return f;
@@ -220,7 +212,7 @@ I memmove_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
       boost::container::iterator_advance(r, n);
    }
@@ -295,13 +287,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -340,13 +332,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -385,13 +377,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -430,13 +422,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -475,13 +467,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -520,13 +512,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (n--) {
-         boost::container::construct_in_place(a, container_detail::iterator_to_raw_pointer(r), f);
+         boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -564,13 +556,13 @@ inline typename container_detail::disable_if_memzero_initializable<F, F>::type
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r));
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -585,7 +577,7 @@ inline typename container_detail::enable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
-   std::memset((void*)container_detail::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
+   std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
    boost::container::iterator_advance(r, n);
    return r;
 }
@@ -611,13 +603,13 @@ inline F uninitialized_default_init_alloc_n(Allocator &a, typename boost::contai
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), default_init);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -647,13 +639,13 @@ inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
    F back = f;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
          ++f;
       }
    }
    BOOST_CATCH(...){
       for (; back != l; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -683,13 +675,13 @@ inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename boost::co
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), v);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -890,7 +882,7 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    const typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
    r -= n;
-   std::memmove((container_detail::iterator_to_raw_pointer)(r), (container_detail::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+   std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
    return r;
 }
 
@@ -963,8 +955,9 @@ template
 inline typename container_detail::disable_if_trivially_destructible<I, void>::type
    destroy_alloc_n(Allocator &a, I f, U n)
 {
-   while(n--){
-      allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(f));
+   while(n){
+      --n;
+      allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
       ++f;
    }
 }
@@ -1021,9 +1014,9 @@ inline typename container_detail::enable_if_c
    storage_type storage;
 
    const std::size_t n_i_bytes = sizeof(value_type)*n_i;
-   void *const large_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f));
-   void *const short_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f));
-   void *const stora_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(storage));
+   void *const large_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f));
+   void *const short_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f));
+   void *const stora_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(storage));
    std::memcpy(stora_ptr, large_ptr, n_i_bytes);
    std::memcpy(large_ptr, short_ptr, n_i_bytes);
    std::memcpy(short_ptr, stora_ptr, n_i_bytes);
@@ -1052,8 +1045,8 @@ inline typename container_detail::enable_if_c
    const std::size_t sizeof_storage = sizeof(storage);
 
    std::size_t n_i_bytes = sizeof(value_type)*n_i;
-   char *large_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f)));
-   char *short_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f)));
+   char *large_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f)));
+   char *short_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f)));
    char *stora_ptr = static_cast<char*>(static_cast<void*>(&storage));
 
    std::size_t szt_times = n_i_bytes/sizeof_storage;
@@ -1072,21 +1065,21 @@ inline typename container_detail::enable_if_c
          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
-         BOOST_CONTAINER_FALLTHOUGH
+         BOOST_FALLTHROUGH;
       case 3:
          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
          std::memcpy(large_ptr, short_ptr, sizeof_storage);
          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
-         BOOST_CONTAINER_FALLTHOUGH
+         BOOST_FALLTHROUGH;
       case 2:
          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
          std::memcpy(large_ptr, short_ptr, sizeof_storage);
          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
          large_ptr += sizeof_storage;
          short_ptr += sizeof_storage;
-         BOOST_CONTAINER_FALLTHOUGH
+         BOOST_FALLTHROUGH;
       case 1:
          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
          std::memcpy(large_ptr, short_ptr, sizeof_storage);
diff --git a/boost/container/detail/destroyers.hpp b/boost/container/detail/destroyers.hpp
index 52b44c0..c3a5d90 100644
--- a/boost/container/detail/destroyers.hpp
+++ b/boost/container/detail/destroyers.hpp
@@ -25,7 +25,7 @@
 #include <boost/container/detail/workaround.hpp>
 
 #include <boost/container/allocator_traits.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/version_type.hpp>
 
 namespace boost {
@@ -152,7 +152,7 @@ struct scoped_destroy_deallocator
    ~scoped_destroy_deallocator()
    {
       if(m_ptr){
-         AllocTraits::destroy(m_alloc, container_detail::to_raw_pointer(m_ptr));
+         AllocTraits::destroy(m_alloc, boost::movelib::to_raw_pointer(m_ptr));
          priv_deallocate(m_ptr, alloc_version());
       }
    }
@@ -202,7 +202,7 @@ struct scoped_destructor_n
    ~scoped_destructor_n()
    {
       if(!m_p) return;
-      value_type *raw_ptr = container_detail::to_raw_pointer(m_p);
+      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
       while(m_n--){
          AllocTraits::destroy(m_a, raw_ptr++);
       }
@@ -270,12 +270,12 @@ class scoped_destructor
 };
 
 
-template<class Allocator>
+template<class Allocator, class Value = typename Allocator::value_type>
 class value_destructor
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
-   typedef typename Allocator::value_type value_type;
+   typedef Value value_type;
    value_destructor(Allocator &a, value_type &rv)
       : rv_(rv), a_(a)
    {}
@@ -317,7 +317,7 @@ class allocator_destroyer
 
    void operator()(const pointer &p)
    {
-      AllocTraits::destroy(a_, container_detail::to_raw_pointer(p));
+      AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
       this->priv_deallocate(p, alloc_version());
    }
 };
@@ -339,7 +339,7 @@ class allocator_destroyer_and_chain_builder
 
    void operator()(const typename Allocator::pointer &p)
    {
-      allocator_traits<Allocator>::destroy(a_, container_detail::to_raw_pointer(p));
+      allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
       c_.push_back(p);
    }
 };
diff --git a/boost/container/detail/flat_tree.hpp b/boost/container/detail/flat_tree.hpp
index 93984d1..319cad6 100644
--- a/boost/container/detail/flat_tree.hpp
+++ b/boost/container/detail/flat_tree.hpp
@@ -28,30 +28,274 @@
 
 #include <boost/container/detail/pair.hpp>
 #include <boost/container/vector.hpp>
+#include <boost/container/allocator_traits.hpp>
+
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/is_sorted.hpp>
-#include <boost/container/allocator_traits.hpp>
-#ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-#include <boost/intrusive/pointer_traits.hpp>
-#endif
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/iterators.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/is_contiguous_container.hpp>
+#include <boost/container/detail/is_container.hpp>
+
+#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
+
 #include <boost/move/make_unique.hpp>
+#include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/adaptive_sort.hpp>
+
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 
-#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
-#include <boost/move/iterator.hpp>
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//merge_unique
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME merge_unique
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 3
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 3
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//merge_equal
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME merge
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 3
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 3
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//index_of
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME index_of
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 1
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//nth
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME nth
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 1
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//reserve
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME reserve
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 1
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//capacity
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME capacity
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 namespace boost {
 namespace container {
 namespace container_detail {
 
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(stored_allocator_type)
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+{
+   dest.merge(first, last, comp);
+}
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+{
+   typedef typename SequenceContainer::iterator    iterator;
+   typedef typename SequenceContainer::value_type  value_type;
+
+   iterator const it = dest.insert( dest.end(), first, last );
+   value_type *const braw = boost::movelib::iterator_to_raw_pointer(dest.begin());
+   value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
+   value_type *const eraw = boost::movelib::iterator_to_raw_pointer(dest.end());
+   value_type *const sraw = boost::movelib::iterator_to_raw_pointer(dest.begin()+dest.size());
+   boost::movelib::adaptive_sort(iraw, eraw, comp, sraw, dest.capacity());
+   boost::movelib::adaptive_merge(braw, iraw, eraw, comp, sraw, dest.capacity()- dest.size());
+}
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+{
+   typedef typename SequenceContainer::iterator    iterator;
+
+   iterator const it = dest.insert( dest.end(), first, last );
+   boost::movelib::adaptive_sort(it, dest.end(), comp);
+   boost::movelib::adaptive_merge(dest.begin(), it, dest.end(), comp);
+}
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+{
+   (flat_tree_merge_equal_non_merge_member)( dest, first, last, comp
+                                           , container_detail::bool_<is_contiguous_container<SequenceContainer>::value>());
+}
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+{
+   dest.merge_unique(first, last, comp);
+}
+
+template<class SequenceContainer, class Iterator, class Compare>
+BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+{
+   (flat_tree_merge_equal)(dest, first, last, comp, container_detail::false_());
+   dest.erase(boost::movelib::unique
+      (dest.begin(), dest.end(), boost::movelib::negate<Compare>(comp)), dest.cend());
+}
+
+template<class SequenceContainer, class Iterator>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+   flat_tree_index_of
+      (SequenceContainer& cont, Iterator p, container_detail::true_)
+{
+   return cont.index_of(p);
+}
+
+template<class SequenceContainer, class Iterator>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+   flat_tree_index_of
+      (SequenceContainer& cont, Iterator p, container_detail::false_)
+{
+   typedef typename SequenceContainer::size_type size_type;
+   return static_cast<size_type>(p - cont.begin());
+}
+
+template<class Iterator, class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE Iterator
+   flat_tree_nth
+      (SequenceContainer& cont, typename SequenceContainer::size_type n, container_detail::true_)
+{
+   return cont.nth(n);
+}
+
+template<class Iterator, class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE Iterator
+   flat_tree_nth
+      (SequenceContainer& cont, typename SequenceContainer::size_type n, container_detail::false_)
+{
+   return cont.begin()+ n;
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::stored_allocator_type &
+   flat_tree_get_stored_allocator
+      (SequenceContainer& cont, container_detail::true_)
+{
+   return cont.get_stored_allocator();
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE const typename SequenceContainer::stored_allocator_type &
+   flat_tree_get_stored_allocator
+      (const SequenceContainer& cont, container_detail::true_)
+{
+   return cont.get_stored_allocator();
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::allocator_type
+   flat_tree_get_stored_allocator
+      (SequenceContainer& cont, container_detail::false_)
+{
+   return cont.get_allocator();
+}
+
+template<class SequenceContainer, class Compare>
+void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::true_)
+{
+   tseq.clear();
+   boost::movelib::adaptive_sort
+   (boost::movelib::iterator_to_raw_pointer(seq.begin())
+      , boost::movelib::iterator_to_raw_pointer(seq.end())
+      , comp
+      , boost::movelib::iterator_to_raw_pointer(tseq.begin() + tseq.size())
+      , tseq.capacity() - tseq.size());
+   tseq = boost::move(seq);
+}
+
+template<class SequenceContainer, class Compare>
+void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::false_)
+{
+   boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
+   tseq = boost::move(seq);
+}
+
+template<class SequenceContainer, class Compare>
+void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::true_)
+{
+   boost::movelib::adaptive_sort
+      ( boost::movelib::iterator_to_raw_pointer(seq.begin())
+      , boost::movelib::iterator_to_raw_pointer(seq.end())
+      , comp
+      , boost::movelib::iterator_to_raw_pointer(tseq.begin() + tseq.size())
+      , tseq.capacity() - tseq.size());
+   seq.erase(boost::movelib::unique
+      ( seq.begin(), seq.end(), boost::movelib::negate<Compare>(comp))
+      , seq.cend());
+   tseq = boost::move(seq);
+}
+
+template<class SequenceContainer, class Compare>
+void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::false_)
+{
+   boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
+   seq.erase(boost::movelib::unique
+      (seq.begin(), seq.end(), boost::movelib::negate<Compare>(comp)), seq.cend());
+   tseq = boost::move(seq);
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE void
+   flat_tree_reserve(SequenceContainer &tseq, typename SequenceContainer::size_type cap, container_detail::true_)
+{
+   tseq.reserve(cap);
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE void
+   flat_tree_reserve(SequenceContainer &, typename SequenceContainer::size_type, container_detail::false_)
+{
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+   flat_tree_capacity(const SequenceContainer &tseq, container_detail::true_)
+{
+   return tseq.capacity();
+}
+
+template<class SequenceContainer>
+BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
+   flat_tree_capacity(const SequenceContainer &tseq, container_detail::false_)
+{
+   return tseq.size();
+}
+
 template<class Compare, class Value, class KeyOfValue>
 class flat_tree_value_compare
    : private Compare
@@ -80,39 +324,49 @@ class flat_tree_value_compare
    Compare &get_comp()
       {  return *this;  }
 };
-
+/*
 template<class Pointer>
 struct get_flat_tree_iterators
 {
-   #ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-   typedef Pointer                                             iterator;
-   typedef typename boost::intrusive::
-      pointer_traits<Pointer>::element_type                    iterator_element_type;
-   typedef typename boost::intrusive::
-      pointer_traits<Pointer>:: template
-         rebind_pointer<const iterator_element_type>::type     const_iterator;
-   #else //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
    typedef typename boost::container::container_detail::
       vec_iterator<Pointer, false>                             iterator;
    typedef typename boost::container::container_detail::
       vec_iterator<Pointer, true >                             const_iterator;
-   #endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
    typedef boost::container::reverse_iterator<iterator>        reverse_iterator;
    typedef boost::container::reverse_iterator<const_iterator>  const_reverse_iterator;
 };
+*/
+
+template < class Value, class AllocatorOrContainer
+         , bool = boost::container::container_detail::is_container<AllocatorOrContainer>::value >
+struct select_container_type
+{
+   typedef AllocatorOrContainer type;
+};
+
+template <class Value, class AllocatorOrContainer>
+struct select_container_type<Value, AllocatorOrContainer, false>
+{
+   typedef boost::container::vector<Value, AllocatorOrContainer> type;
+};
 
 template <class Value, class KeyOfValue,
-          class Compare, class Allocator>
+          class Compare, class AllocatorOrContainer>
 class flat_tree
 {
-   typedef boost::container::vector<Value, Allocator>    vector_t;
-   typedef Allocator                                     allocator_t;
-   typedef allocator_traits<Allocator>                   allocator_traits_type;
+   public:
+   typedef typename select_container_type<Value, AllocatorOrContainer>::type container_type;
+   typedef container_type sequence_type;  //For backwards compatibility
+
+   private:
+   typedef typename container_type::allocator_type        allocator_t;
+   typedef allocator_traits<allocator_t>                 allocator_traits_type;
 
    public:
    typedef flat_tree_value_compare<Compare, Value, KeyOfValue> value_compare;
 
- private:
+   private:
+   
    struct Data
       //Inherit from value_compare to do EBO
       : public value_compare
@@ -121,48 +375,48 @@ class flat_tree
 
       public:
       Data()
-         : value_compare(), m_vect()
-      {}
-
-      explicit Data(const Data &d)
-         : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect)
-      {}
-
-      Data(BOOST_RV_REF(Data) d)
-         : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect))
-      {}
-
-      Data(const Data &d, const Allocator &a)
-         : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect, a)
-      {}
-
-      Data(BOOST_RV_REF(Data) d, const Allocator &a)
-         : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect), a)
-      {}
-
-      explicit Data(const Compare &comp)
-         : value_compare(comp), m_vect()
-      {}
-
-      Data(const Compare &comp, const allocator_t &alloc)
-         : value_compare(comp), m_vect(alloc)
+         : value_compare(), m_seq()
       {}
 
       explicit Data(const allocator_t &alloc)
-         : value_compare(), m_vect(alloc)
+         : value_compare(), m_seq(alloc)
+      {}
+
+      explicit Data(const Compare &comp)
+         : value_compare(comp), m_seq()
+      {}
+
+      Data(const Compare &comp, const allocator_t &alloc)
+         : value_compare(comp), m_seq(alloc)
+      {}
+
+      explicit Data(const Data &d)
+         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq)
+      {}
+
+      Data(BOOST_RV_REF(Data) d)
+         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq))
+      {}
+
+      Data(const Data &d, const allocator_t &a)
+         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq, a)
+      {}
+
+      Data(BOOST_RV_REF(Data) d, const allocator_t &a)
+         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq), a)
       {}
 
       Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
       {
          this->value_compare::operator=(d);
-         m_vect = d.m_vect;
+         m_seq = d.m_seq;
          return *this;
       }
 
       Data& operator=(BOOST_RV_REF(Data) d)
       {
          this->value_compare::operator=(boost::move(static_cast<value_compare &>(d)));
-         m_vect = boost::move(d.m_vect);
+         m_seq = boost::move(d.m_seq);
          return *this;
       }
 
@@ -170,10 +424,10 @@ class flat_tree
       {
          value_compare& mycomp    = *this, & othercomp = d;
          boost::adl_move_swap(mycomp, othercomp);
-         this->m_vect.swap(d.m_vect);
+         this->m_seq.swap(d.m_seq);
       }
 
-      vector_t m_vect;
+      container_type m_seq;
    };
 
    Data m_data;
@@ -181,28 +435,39 @@ class flat_tree
 
    public:
 
-   typedef typename vector_t::value_type              value_type;
-   typedef typename vector_t::pointer                 pointer;
-   typedef typename vector_t::const_pointer           const_pointer;
-   typedef typename vector_t::reference               reference;
-   typedef typename vector_t::const_reference         const_reference;
-   typedef typename KeyOfValue::type                  key_type;
-   typedef Compare                                    key_compare;
-   typedef typename vector_t::allocator_type          allocator_type;
-   typedef typename vector_t::size_type               size_type;
-   typedef typename vector_t::difference_type         difference_type;
-   typedef typename vector_t::iterator                iterator;
-   typedef typename vector_t::const_iterator          const_iterator;
-   typedef typename vector_t::reverse_iterator        reverse_iterator;
-   typedef typename vector_t::const_reverse_iterator  const_reverse_iterator;
+   typedef typename container_type::value_type               value_type;
+   typedef typename container_type::pointer                  pointer;
+   typedef typename container_type::const_pointer            const_pointer;
+   typedef typename container_type::reference                reference;
+   typedef typename container_type::const_reference          const_reference;
+   typedef typename KeyOfValue::type                        key_type;
+   typedef Compare                                          key_compare;
+   typedef typename container_type::allocator_type           allocator_type;
+   typedef typename container_type::size_type                size_type;
+   typedef typename container_type::difference_type          difference_type;
+   typedef typename container_type::iterator                 iterator;
+   typedef typename container_type::const_iterator           const_iterator;
+   typedef typename container_type::reverse_iterator         reverse_iterator;
+   typedef typename container_type::const_reverse_iterator   const_reverse_iterator;
 
    //!Standard extension
-   typedef allocator_type                             stored_allocator_type;
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+      (boost::container::container_detail::, container_type
+      ,stored_allocator_type, allocator_type)               stored_allocator_type;
+
+   static const bool has_stored_allocator_type =
+      BOOST_INTRUSIVE_HAS_TYPE(boost::container::container_detail::, container_type, stored_allocator_type);
 
    private:
    typedef allocator_traits<stored_allocator_type> stored_allocator_traits;
 
    public:
+   typedef typename container_detail::if_c
+      <has_stored_allocator_type, const stored_allocator_type &, allocator_type>::type get_stored_allocator_const_return_t;
+
+   typedef typename container_detail::if_c
+      <has_stored_allocator_type, stored_allocator_type &, allocator_type>::type get_stored_allocator_noconst_return_t;
+
    BOOST_CONTAINER_FORCEINLINE flat_tree()
       : m_data()
    { }
@@ -211,14 +476,14 @@ class flat_tree
       : m_data(comp)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
-      : m_data(comp, a)
-   { }
-
    BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const allocator_type& a)
       : m_data(a)
    { }
 
+   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   { }
+
    BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
@@ -237,46 +502,92 @@ class flat_tree
    { }
 
    template <class InputIterator>
-   flat_tree( ordered_range_t, InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
-      : m_data(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last)
+      : m_data()
    {
-      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
-      BOOST_ASSERT((is_sorted)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
    }
 
    template <class InputIterator>
-   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
-      : m_data(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_data(comp)
    {
-      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
-      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
    }
 
    template <class InputIterator>
-   flat_tree( bool unique_insertion
-            , InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    {
-      //Use cend() as hint to achieve linear time for
-      //ordered ranges as required by the standard
-      //for the constructor
-      //Call end() every iteration as reallocation might have invalidated iterators
-      if(unique_insertion){
-         for ( ; first != last; ++first){
-            this->insert_unique(this->cend(), *first);
-         }
-      }
-      else{
-         for ( ; first != last; ++first){
-            this->insert_equal(this->cend(), *first);
-         }
-      }
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : m_data()
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_data(comp)
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last)
+      : m_data()
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const Compare& comp)
+      : m_data(comp)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const allocator_type& a)
+      : m_data(a)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
    }
 
    BOOST_CONTAINER_FORCEINLINE ~flat_tree()
@@ -303,6 +614,11 @@ class flat_tree
    BOOST_CONTAINER_FORCEINLINE key_compare &priv_key_comp()
    { return this->priv_value_comp().get_comp(); }
 
+   struct insert_commit_data
+   {
+      const_iterator position;
+   };
+
    public:
    // accessors:
    BOOST_CONTAINER_FORCEINLINE Compare key_comp() const
@@ -312,31 +628,35 @@ class flat_tree
    { return this->m_data; }
 
    BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const
-   { return this->m_data.m_vect.get_allocator(); }
+   { return this->m_data.m_seq.get_allocator(); }
 
-   BOOST_CONTAINER_FORCEINLINE const stored_allocator_type &get_stored_allocator() const
-   {  return this->m_data.m_vect.get_stored_allocator(); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_const_return_t get_stored_allocator() const
+   {
+      return flat_tree_get_stored_allocator(this->m_data.m_seq, container_detail::bool_<has_stored_allocator_type>());
+   }
 
-   BOOST_CONTAINER_FORCEINLINE stored_allocator_type &get_stored_allocator()
-   {  return this->m_data.m_vect.get_stored_allocator(); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_noconst_return_t get_stored_allocator()
+   {
+      return flat_tree_get_stored_allocator(this->m_data.m_seq, container_detail::bool_<has_stored_allocator_type>());
+   }
 
    BOOST_CONTAINER_FORCEINLINE iterator begin()
-   { return this->m_data.m_vect.begin(); }
+   { return this->m_data.m_seq.begin(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator begin() const
    { return this->cbegin(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const
-   { return this->m_data.m_vect.begin(); }
+   { return this->m_data.m_seq.begin(); }
 
    BOOST_CONTAINER_FORCEINLINE iterator end()
-   { return this->m_data.m_vect.end(); }
+   { return this->m_data.m_seq.end(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator end() const
    { return this->cend(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator cend() const
-   { return this->m_data.m_vect.end(); }
+   { return this->m_data.m_seq.end(); }
 
    BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
@@ -357,13 +677,13 @@ class flat_tree
    { return const_reverse_iterator(this->cbegin()); }
 
    BOOST_CONTAINER_FORCEINLINE bool empty() const
-   { return this->m_data.m_vect.empty(); }
+   { return this->m_data.m_seq.empty(); }
 
    BOOST_CONTAINER_FORCEINLINE size_type size() const
-   { return this->m_data.m_vect.size(); }
+   { return this->m_data.m_seq.size(); }
 
    BOOST_CONTAINER_FORCEINLINE size_type max_size() const
-   { return this->m_data.m_vect.max_size(); }
+   { return this->m_data.m_seq.max_size(); }
 
    BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
@@ -378,7 +698,8 @@ class flat_tree
       insert_commit_data data;
       ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
       ret.first = ret.second ? this->priv_insert_commit(data, val)
-                             : iterator(vector_iterator_get_ptr(data.position));
+                             : this->begin() + (data.position - this->cbegin());
+                             //: iterator(vector_iterator_get_ptr(data.position));
       return ret;
    }
 
@@ -388,21 +709,22 @@ class flat_tree
       insert_commit_data data;
       ret.second = this->priv_insert_unique_prepare(KeyOfValue()(val), data);
       ret.first = ret.second ? this->priv_insert_commit(data, boost::move(val))
-                             : iterator(vector_iterator_get_ptr(data.position));
+                             : this->begin() + (data.position - this->cbegin());
+                             //: iterator(vector_iterator_get_ptr(data.position));
       return ret;
    }
 
    iterator insert_equal(const value_type& val)
    {
       iterator i = this->upper_bound(KeyOfValue()(val));
-      i = this->m_data.m_vect.insert(i, val);
+      i = this->m_data.m_seq.insert(i, val);
       return i;
    }
 
    iterator insert_equal(BOOST_RV_REF(value_type) mval)
    {
       iterator i = this->upper_bound(KeyOfValue()(mval));
-      i = this->m_data.m_vect.insert(i, boost::move(mval));
+      i = this->m_data.m_seq.insert(i, boost::move(mval));
       return i;
    }
 
@@ -412,7 +734,8 @@ class flat_tree
       insert_commit_data data;
       return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
             ? this->priv_insert_commit(data, val)
-            : iterator(vector_iterator_get_ptr(data.position));
+            : this->begin() + (data.position - this->cbegin());
+            //: iterator(vector_iterator_get_ptr(data.position));
    }
 
    iterator insert_unique(const_iterator hint, BOOST_RV_REF(value_type) val)
@@ -421,7 +744,8 @@ class flat_tree
       insert_commit_data data;
       return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
          ? this->priv_insert_commit(data, boost::move(val))
-         : iterator(vector_iterator_get_ptr(data.position));
+         : this->begin() + (data.position - this->cbegin());
+         //: iterator(vector_iterator_get_ptr(data.position));
    }
 
    iterator insert_equal(const_iterator hint, const value_type& val)
@@ -509,7 +833,11 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge(first, last, static_cast<const value_compare &>(this->m_data));   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
+      (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), container_detail::bool_<value>());
+   }
 
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last
@@ -538,7 +866,11 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge_unique(first, last, static_cast<const value_compare &>(this->m_data));   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
+      (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), container_detail::bool_<value>());
+   }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -547,9 +879,9 @@ class flat_tree
    {
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
-      stored_allocator_type &a = this->get_stored_allocator();
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type> d(a, val);
+      value_destructor<stored_allocator_type, value_type> d(a, val);
       return this->insert_unique(::boost::move(val));
    }
 
@@ -559,9 +891,9 @@ class flat_tree
       //hint checked in insert_unique
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
-      stored_allocator_type &a = this->get_stored_allocator();
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type> d(a, val);
+      value_destructor<stored_allocator_type, value_type> d(a, val);
       return this->insert_unique(hint, ::boost::move(val));
    }
 
@@ -570,9 +902,9 @@ class flat_tree
    {
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
-      stored_allocator_type &a = this->get_stored_allocator();
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type> d(a, val);
+      value_destructor<stored_allocator_type, value_type> d(a, val);
       return this->insert_equal(::boost::move(val));
    }
 
@@ -582,9 +914,9 @@ class flat_tree
       //hint checked in insert_equal
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));
-      stored_allocator_type &a = this->get_stored_allocator();
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
-      value_destructor<stored_allocator_type> d(a, val);
+      value_destructor<stored_allocator_type, value_type> d(a, val);
       return this->insert_equal(hint, ::boost::move(val));
    }
 
@@ -606,7 +938,7 @@ class flat_tree
          typedef typename emplace_functor_type<try_emplace_t, KeyType, Args...>::type func_t;
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;
          func_t func(try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
       }
       return ret;
    }
@@ -619,9 +951,9 @@ class flat_tree
    {\
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));\
-      stored_allocator_type &a = this->get_stored_allocator();\
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type> d(a, val);\
+      value_destructor<stored_allocator_type, value_type> d(a, val);\
       return this->insert_unique(::boost::move(val));\
    }\
    \
@@ -630,9 +962,9 @@ class flat_tree
    {\
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));\
-      stored_allocator_type &a = this->get_stored_allocator();\
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type> d(a, val);\
+      value_destructor<stored_allocator_type, value_type> d(a, val);\
       return this->insert_unique(hint, ::boost::move(val));\
    }\
    \
@@ -641,9 +973,9 @@ class flat_tree
    {\
       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));\
-      stored_allocator_type &a = this->get_stored_allocator();\
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type> d(a, val);\
+      value_destructor<stored_allocator_type, value_type> d(a, val);\
       return this->insert_equal(::boost::move(val));\
    }\
    \
@@ -652,9 +984,9 @@ class flat_tree
    {\
       typename aligned_storage <sizeof(value_type), alignment_of<value_type>::value>::type v;\
       value_type &val = *static_cast<value_type *>(static_cast<void *>(&v));\
-      stored_allocator_type &a = this->get_stored_allocator();\
+      get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
       stored_allocator_traits::construct(a, &val BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_destructor<stored_allocator_type> d(a, val);\
+      value_destructor<stored_allocator_type, value_type> d(a, val);\
       return this->insert_equal(hint, ::boost::move(val));\
    }\
    template <class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
@@ -675,7 +1007,7 @@ class flat_tree
          typedef typename emplace_functor_type<try_emplace_t, KeyType BOOST_MOVE_I##N BOOST_MOVE_TARG##N>::type func_t;\
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;\
          func_t func(try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());\
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());\
       }\
       return ret;\
    }\
@@ -702,29 +1034,29 @@ class flat_tree
          typedef typename emplace_functor_type<KeyType, M>::type func_t;
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;
          func_t func(boost::forward<KeyType>(key), boost::forward<M>(obj));
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
       }
       return ret;
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator position)
-   {  return this->m_data.m_vect.erase(position);  }
+   {  return this->m_data.m_seq.erase(position);  }
 
    size_type erase(const key_type& k)
    {
       std::pair<iterator,iterator > itp = this->equal_range(k);
       size_type ret = static_cast<size_type>(itp.second-itp.first);
       if (ret){
-         this->m_data.m_vect.erase(itp.first, itp.second);
+         this->m_data.m_seq.erase(itp.first, itp.second);
       }
       return ret;
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
-   {  return this->m_data.m_vect.erase(first, last);  }
+   {  return this->m_data.m_seq.erase(first, last);  }
 
    BOOST_CONTAINER_FORCEINLINE void clear()
-   {  this->m_data.m_vect.clear();  }
+   {  this->m_data.m_seq.clear();  }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    //    with previous allocations. The size of the vector is unchanged
@@ -733,19 +1065,35 @@ class flat_tree
    //!
    //! <b>Complexity</b>: Linear to size().
    BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
-   {  this->m_data.m_vect.shrink_to_fit();  }
+   {  this->m_data.m_seq.shrink_to_fit();  }
 
    BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.nth(n);   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_nth<container_type, size_type>::value;
+      return flat_tree_nth<iterator>(this->m_data.m_seq, n, container_detail::bool_<value>());
+   }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.nth(n);   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_nth<container_type, size_type>::value;
+      return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, container_detail::bool_<value>());
+   }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.index_of(p);   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_index_of<container_type, iterator>::value;
+      return flat_tree_index_of(this->m_data.m_seq, p, container_detail::bool_<value>());
+   }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.index_of(p);   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_index_of<container_type, const_iterator>::value;
+      return flat_tree_index_of(this->m_data.m_seq, p, container_detail::bool_<value>());
+   }
 
    // set operations:
    iterator find(const key_type& k)
@@ -778,33 +1126,41 @@ class flat_tree
    }
 
    template<class C2>
-   void merge_unique(flat_tree<Value, KeyOfValue, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
       this->insert( boost::make_move_iterator(source.begin())
                   , boost::make_move_iterator(source.end()));
    }
 
    template<class C2>
-   void merge_equal(flat_tree<Value, KeyOfValue, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree<Value, KeyOfValue, C2, AllocatorOrContainer>& source)
    {
       this->insert( boost::make_move_iterator(source.begin())
                   , boost::make_move_iterator(source.end()));
    }
 
-   void merge_unique(flat_tree& source)
+   BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree& source)
    {
-      this->m_data.m_vect.merge_unique
-         ( boost::make_move_iterator(source.begin())
-         , boost::make_move_iterator(source.end())
-         , static_cast<const value_compare &>(this->m_data));
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
+      (flat_tree_merge_unique)
+         ( this->m_data.m_seq
+         , boost::make_move_iterator(source.m_data.m_seq.begin())
+         , boost::make_move_iterator(source.m_data.m_seq.end())
+         , this->priv_value_comp()
+         , container_detail::bool_<value>());
    }
 
-   void merge_equal(flat_tree& source)
+   BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree& source)
    {
-      this->m_data.m_vect.merge
-         ( boost::make_move_iterator(source.begin())
-         , boost::make_move_iterator(source.end())
-         , static_cast<const value_compare &>(this->m_data));
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_merge<container_type, iterator, iterator, value_compare>::value;
+      (flat_tree_merge_equal)
+         ( this->m_data.m_seq
+         , boost::make_move_iterator(source.m_data.m_seq.begin())
+         , boost::make_move_iterator(source.m_data.m_seq.end())
+         , this->priv_value_comp()
+         , container_detail::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& k)
@@ -832,10 +1188,52 @@ class flat_tree
    {  return this->priv_lower_bound_range(this->cbegin(), this->cend(), k);  }
 
    BOOST_CONTAINER_FORCEINLINE size_type capacity() const
-   { return this->m_data.m_vect.capacity(); }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_capacity<container_type>::value;
+      return (flat_tree_capacity)(this->m_data.m_seq, container_detail::bool_<value>());
+   }
 
    BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
-   { this->m_data.m_vect.reserve(cnt);   }
+   {
+      const bool value = boost::container::container_detail::
+         has_member_function_callable_with_reserve<container_type, size_type>::value;
+      (flat_tree_reserve)(this->m_data.m_seq, cnt, container_detail::bool_<value>());
+   }
+
+   BOOST_CONTAINER_FORCEINLINE container_type extract_sequence()
+   {
+      return boost::move(m_data.m_seq);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE container_type &get_sequence_ref()
+   {
+      return m_data.m_seq;
+   }
+
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence_equal(BOOST_RV_REF(container_type) seq)
+   {
+      (flat_tree_adopt_sequence_equal)( m_data.m_seq, boost::move(seq), this->priv_value_comp()
+         , container_detail::bool_<is_contiguous_container<container_type>::value>());
+   }
+
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence_unique(BOOST_RV_REF(container_type) seq)
+   {
+      (flat_tree_adopt_sequence_unique)(m_data.m_seq, boost::move(seq), this->priv_value_comp()
+         , container_detail::bool_<is_contiguous_container<container_type>::value>());
+   }
+
+   void adopt_sequence_equal(ordered_range_t, BOOST_RV_REF(container_type) seq)
+   {
+      BOOST_ASSERT((is_sorted)(seq.cbegin(), seq.cend(), this->priv_value_comp()));
+      m_data.m_seq = boost::move(seq);
+   }
+
+   void adopt_sequence_unique(ordered_unique_range_t, BOOST_RV_REF(container_type) seq)
+   {
+      BOOST_ASSERT((is_sorted_and_unique)(seq.cbegin(), seq.cend(), this->priv_value_comp()));
+      m_data.m_seq = boost::move(seq);
+   }
 
    BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_tree& x, const flat_tree& y)
    {
@@ -864,16 +1262,30 @@ class flat_tree
 
    private:
 
+   template <class InputIterator>
+   void priv_range_insertion_construct( bool unique_insertion, InputIterator first, InputIterator last)
+   {
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      //Call end() every iteration as reallocation might have invalidated iterators
+      if(unique_insertion){
+         for ( ; first != last; ++first){
+            this->insert_unique(this->cend(), *first);
+         }
+      }
+      else{
+         for ( ; first != last; ++first){
+            this->insert_equal(this->cend(), *first);
+         }
+      }
+   }
+
    BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
    }
 
-   struct insert_commit_data
-   {
-      const_iterator position;
-   };
-
    // insert/erase
    void priv_insert_equal_prepare
       (const_iterator pos, const value_type& val, insert_commit_data &data)
@@ -963,7 +1375,7 @@ class flat_tree
    BOOST_CONTAINER_FORCEINLINE iterator priv_insert_commit
       (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
    {
-      return this->m_data.m_vect.insert
+      return this->m_data.m_seq.insert
          ( commit_data.position
          , boost::forward<Convertible>(convertible));
    }
@@ -1092,11 +1504,13 @@ class flat_tree
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
 template <class T, class KeyOfValue,
-class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<T, KeyOfValue, Compare, Allocator> >
+class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename boost::container::container_detail::select_container_type<T, AllocatorOrContainer>::type container_type;
+   typedef typename container_type::allocator_type allocator_t;
+   typedef typename ::boost::container::allocator_traits<allocator_t>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_t>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value;
 };
 
diff --git a/boost/container/detail/is_container.hpp b/boost/container/detail/is_container.hpp
new file mode 100644
index 0000000..6052f04
--- /dev/null
+++ b/boost/container/detail/is_container.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP
+#define BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//empty
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME empty
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+//size
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME size
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+template <class Container>
+struct is_container
+{
+   static const bool value =
+      boost::container::is_container_detail::
+         has_member_function_callable_with_size <const Container>::value &&
+      boost::container::is_container_detail::
+         has_member_function_callable_with_empty<const Container>::value;
+};
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_IS_CONTAINER_HPP
diff --git a/boost/container/detail/is_contiguous_container.hpp b/boost/container/detail/is_contiguous_container.hpp
new file mode 100644
index 0000000..af98c7f
--- /dev/null
+++ b/boost/container/detail/is_contiguous_container.hpp
@@ -0,0 +1,47 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP
+#define BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+//data
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME data
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace is_contiguous_container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+namespace boost {
+namespace container {
+namespace container_detail {
+
+template <class Container>
+struct is_contiguous_container
+{
+   static const bool value =
+      boost::container::is_contiguous_container_detail::
+         has_member_function_callable_with_data<Container>::value && 
+      boost::container::is_contiguous_container_detail::
+         has_member_function_callable_with_data<const Container>::value;
+};
+
+}  //namespace container_detail {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_IS_CONTIGUOUS_CONTAINER_HPP
diff --git a/boost/container/detail/multiallocation_chain.hpp b/boost/container/detail/multiallocation_chain.hpp
index 32f87c8..bce1b86 100644
--- a/boost/container/detail/multiallocation_chain.hpp
+++ b/boost/container/detail/multiallocation_chain.hpp
@@ -24,7 +24,7 @@
 // container
 #include <boost/container/container_fwd.hpp>
 // container/detail
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/transform_iterator.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
@@ -63,7 +63,7 @@ class basic_multiallocation_chain
       pointer_traits<node_ptr>                              node_ptr_traits;
 
    static node & to_node(const VoidPointer &p)
-   {  return *static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p)));  }
+   {  return *static_cast<node*>(static_cast<void*>(boost::movelib::to_raw_pointer(p)));  }
 
    static VoidPointer from_node(node &n)
    {  return node_ptr_traits::pointer_to(n);  }
@@ -152,7 +152,7 @@ class basic_multiallocation_chain
          char_ptr prev_elem = elem;
          elem += unit_bytes;
          for(size_type i = 0; i != num_units-1; ++i, elem += unit_bytes){
-            ::new (container_detail::to_raw_pointer(prev_elem)) void_pointer(elem);
+            ::new (boost::movelib::to_raw_pointer(prev_elem)) void_pointer(elem);
             prev_elem = elem;
          }
          slist_impl_.incorporate_after(after_this, to_node_ptr(b), to_node_ptr(prev_elem), num_units);
diff --git a/boost/container/detail/node_alloc_holder.hpp b/boost/container/detail/node_alloc_holder.hpp
index 7ef5d28..b6e602e 100644
--- a/boost/container/detail/node_alloc_holder.hpp
+++ b/boost/container/detail/node_alloc_holder.hpp
@@ -30,10 +30,10 @@
 #include <boost/container/detail/allocator_version_traits.hpp>
 #include <boost/container/detail/construct_in_place.hpp>
 #include <boost/container/detail/destroyers.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/version_type.hpp>
 // intrusive
@@ -106,23 +106,23 @@ struct node_alloc_holder
       : members_(a)
    {}
 
+   //Constructors for associative containers
+   node_alloc_holder(const value_compare &c, const ValAlloc &a)
+      : members_(a, c)
+   {}
+
    explicit node_alloc_holder(const node_alloc_holder &x)
       : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()))
    {}
 
+   node_alloc_holder(const node_alloc_holder &x, const value_compare &c)
+      : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
+   {}
+
    explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x)
       : members_(boost::move(x.node_alloc()))
    {  this->icont().swap(x.icont());  }
 
-   //Constructors for associative containers
-   explicit node_alloc_holder(const value_compare &c, const ValAlloc &a)
-      : members_(a, c)
-   {}
-
-   explicit node_alloc_holder(const value_compare &c, const node_alloc_holder &x)
-      : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
-   {}
-
    explicit node_alloc_holder(const value_compare &c)
       : members_(c)
    {}
@@ -171,7 +171,7 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
@@ -189,7 +189,7 @@ struct node_alloc_holder
           BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       node_deallocator.release();\
       typedef typename Node::hook_type hook_type;\
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;\
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;\
       return (p);\
    }\
    //
@@ -207,7 +207,7 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
@@ -230,13 +230,13 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
    void destroy_node(const NodePtr &nodep)
    {
-      allocator_traits<NodeAlloc>::destroy(this->node_alloc(), container_detail::to_raw_pointer(nodep));
+      allocator_traits<NodeAlloc>::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(nodep));
       this->deallocate_one(nodep);
    }
 
@@ -266,7 +266,7 @@ struct node_alloc_holder
             Deallocator node_deallocator(NodePtr(), nalloc);
             container_detail::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n--){
-               p = container_detail::iterator_to_raw_pointer(itbeg);
+               p = boost::movelib::iterator_to_raw_pointer(itbeg);
                node_deallocator.set(p);
                ++itbeg;
                //This can throw
diff --git a/boost/container/detail/pair.hpp b/boost/container/detail/pair.hpp
index 4abff4b..4755e56 100644
--- a/boost/container/detail/pair.hpp
+++ b/boost/container/detail/pair.hpp
@@ -35,16 +35,62 @@
 
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/move/utility_core.hpp>
-#include<boost/move/detail/fwd_macros.hpp>
+#include <boost/move/detail/fwd_macros.hpp>
 
 namespace boost {
 namespace tuples {
 
 struct null_type;
 
+template <
+  class T0, class T1, class T2,
+  class T3, class T4, class T5,
+  class T6, class T7, class T8,
+  class T9>
+class tuple;
+
 }  //namespace tuples {
 }  //namespace boost {
 
+namespace boost {
+namespace container {
+namespace pair_impl {
+
+template <class TupleClass>
+struct is_boost_tuple
+{
+   static const bool value = false;
+};
+
+template <
+  class T0, class T1, class T2,
+  class T3, class T4, class T5,
+  class T6, class T7, class T8,
+  class T9>
+struct is_boost_tuple< boost::tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+{
+   static const bool value = true;
+};
+
+template<class Tuple>
+struct disable_if_boost_tuple
+   : boost::container::container_detail::disable_if< is_boost_tuple<Tuple> >
+{};
+
+template<class T>
+struct is_tuple_null
+{
+   static const bool value = false;
+};
+
+template<>
+struct is_tuple_null<boost::tuples::null_type>
+{
+   static const bool value = true;
+};
+
+}}}
+
 #if defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
 //MSVC 2010 tuple marker
 namespace std { namespace tr1 { struct _Nil; }}
@@ -236,7 +282,12 @@ struct pair
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
    pair( piecewise_construct_t\
        , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
-       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
+       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q\
+       , typename container_detail::enable_if_c\
+         < pair_impl::is_boost_tuple< BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> >::value &&\
+           !(pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARG##N>::value || pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARGQ##M>::value) \
+         >::type* = 0\
+       )\
       : first(BOOST_MOVE_TMPL_GET##N), second(BOOST_MOVE_TMPL_GETQ##M)\
    { (void)p; (void)q; }\
    //
@@ -254,7 +305,8 @@ struct pair
       {  (void) t1; (void)t2; }
 
       public:
-      template<template<class ...> class Tuple, class... Args1, class... Args2>
+      template< template<class ...> class Tuple, class... Args1, class... Args2
+              , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : pair(t1, t2, typename build_number_seq<sizeof...(Args1)>::type(), typename build_number_seq<sizeof...(Args2)>::type())
       {}
@@ -270,7 +322,8 @@ struct pair
       {  (void)t; return T(::boost::forward<Args>(get<Indexes>(t))...);  }
 
       public:
-      template<template<class ...> class Tuple, class... Args1, class... Args2>
+      template< template<class ...> class Tuple, class... Args1, class... Args2
+              , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : first  (build_from_args<first_type> (::boost::move(t1)))
          , second (build_from_args<second_type>(::boost::move(t2)))
diff --git a/boost/container/detail/pair_key_mapped_of_value.hpp b/boost/container/detail/pair_key_mapped_of_value.hpp
new file mode 100644
index 0000000..6112b87
--- /dev/null
+++ b/boost/container/detail/pair_key_mapped_of_value.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+#define BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+namespace boost {
+namespace container {
+
+template<class Key, class Mapped>
+struct pair_key_mapped_of_value
+{
+   typedef Key    key_type;
+   typedef Mapped mapped_type;
+
+   template<class Pair>
+   const key_type & key_of_value(const Pair &p) const
+   {  return p.first;  }
+
+   template<class Pair>
+   const mapped_type & mapped_of_value(const Pair &p) const
+   {  return p.second;  }
+
+   template<class Pair>
+   key_type & key_of_value(Pair &p) const
+   {  return const_cast<key_type&>(p.first);  }
+
+   template<class Pair>
+   mapped_type & mapped_of_value(Pair &p) const
+   {  return p.second;  }
+
+};
+
+}}
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   // BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
diff --git a/boost/container/detail/tree.hpp b/boost/container/detail/tree.hpp
index 853d0ad..99baf3a 100644
--- a/boost/container/detail/tree.hpp
+++ b/boost/container/detail/tree.hpp
@@ -493,7 +493,7 @@ class tree
    typedef boost::container::reverse_iterator
       <const_iterator>                                const_reverse_iterator;
    typedef node_handle
-      < Node, value_type, allocator_type, void>       node_type;
+      < NodeAlloc, void>                              node_type;
    typedef insert_return_type_base
       <iterator, node_type>                           insert_return_type;
 
@@ -509,7 +509,11 @@ class tree
       : AllocHolder()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp)
+      : AllocHolder(ValComp(comp))
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a)
       : AllocHolder(ValComp(comp), a)
    {}
 
@@ -518,85 +522,110 @@ class tree
    {}
 
    template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
-      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
-         < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
-         >::type * = 0
-      #endif
-         )
+   tree(bool unique_insertion, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp, const allocator_type& a)
       : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   //construct with ordered range
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last
+         , const key_compare& comp, const allocator_type& a)
+      : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   private:
+
+   template <class InputIterator>
+   void tree_construct(bool unique_insertion, InputIterator first, InputIterator last)
    {
       //Use cend() as hint to achieve linear time for
       //ordered ranges as required by the standard
       //for the constructor
-      const const_iterator end_it(this->cend());
       if(unique_insertion){
-         for ( ; first != last; ++first){
-            this->insert_unique_convertible(end_it, *first);
-         }
-      }
-      else{
-         for ( ; first != last; ++first){
-            this->insert_equal_convertible(end_it, *first);
-         }
-      }
-   }
-
-   template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
-      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
-         < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
-         >::type * = 0
-      #endif
-         )
-      : AllocHolder(value_compare(comp), a)
-   {
-      if(unique_insertion){
-         //Use cend() as hint to achieve linear time for
-         //ordered ranges as required by the standard
-         //for the constructor
          const const_iterator end_it(this->cend());
          for ( ; first != last; ++first){
             this->insert_unique_convertible(end_it, *first);
          }
       }
       else{
-         //Optimized allocation and construction
-         this->allocate_many_and_construct
-            ( first, boost::container::iterator_distance(first, last)
-            , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
+         this->tree_construct_non_unique(first, last);
       }
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
-         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   void tree_construct_non_unique(InputIterator first, InputIterator last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename container_detail::enable_if_or
          < void
          , container_detail::is_same<alloc_version, version_1>
          , container_detail::is_input_iterator<InputIterator>
          >::type * = 0
-         #endif
+      #endif
          )
-      : AllocHolder(value_compare(comp), a)
    {
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      const const_iterator end_it(this->cend());
       for ( ; first != last; ++first){
-         this->push_back_impl(*first);
+         this->insert_equal_convertible(end_it, *first);
       }
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
+   void tree_construct_non_unique(InputIterator first, InputIterator last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_same<alloc_version, version_1>
+         , container_detail::is_input_iterator<InputIterator>
+         >::type * = 0
+      #endif
+         )
+   {
+      //Optimized allocation and construction
+      this->allocate_many_and_construct
+         ( first, boost::container::iterator_distance(first, last)
+         , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
+   }
+
+   template <class InputIterator>
+   void tree_construct( ordered_range_t, InputIterator first, InputIterator last
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename container_detail::disable_if_or
          < void
@@ -605,16 +634,34 @@ class tree
          >::type * = 0
          #endif
          )
-      : AllocHolder(value_compare(comp), a)
    {
       //Optimized allocation and construction
       this->allocate_many_and_construct
          ( first, boost::container::iterator_distance(first, last)
          , container_detail::push_back_functor<Node, Icont>(this->icont()));
+      //AllocHolder clears in case of exception
    }
 
+   template <class InputIterator>
+   void tree_construct( ordered_range_t, InputIterator first, InputIterator last
+         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_or
+         < void
+         , container_detail::is_same<alloc_version, version_1>
+         , container_detail::is_input_iterator<InputIterator>
+         >::type * = 0
+         #endif
+         )
+   {
+      for ( ; first != last; ++first){
+         this->push_back_impl(*first);
+      }
+   }
+
+   public:
+
    BOOST_CONTAINER_FORCEINLINE tree(const tree& x)
-      :  AllocHolder(x.value_comp(), x)
+      :  AllocHolder(x, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
@@ -630,6 +677,7 @@ class tree
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
+      //AllocHolder clears in case of exception
    }
 
    tree(BOOST_RV_REF(tree) x, const allocator_type &a)
@@ -642,6 +690,7 @@ class tree
          this->icont().clone_from
             (boost::move(x.icont()), typename AllocHolder::move_cloner(*this), Destroyer(this->node_alloc()));
       }
+      //AllocHolder clears in case of exception
    }
 
    BOOST_CONTAINER_FORCEINLINE ~tree()
@@ -1142,7 +1191,7 @@ class tree
             this->insert_unique_check(hint, KeyOfValue()(nh.value()), data);
          if(ret.second){
             irt.inserted = true;
-            irt.position = iterator(this->icont().insert_unique_commit(*nh.get_node_pointer(), data));
+            irt.position = iterator(this->icont().insert_unique_commit(*nh.get(), data));
             nh.release();
          }
          else{
diff --git a/boost/container/detail/workaround.hpp b/boost/container/detail/workaround.hpp
index 816d3cc..736326b 100644
--- a/boost/container/detail/workaround.hpp
+++ b/boost/container/detail/workaround.hpp
@@ -43,12 +43,6 @@
 #  endif
 #endif
 
-#if !defined(BOOST_FALLTHOUGH)
-   #define BOOST_CONTAINER_FALLTHOUGH
-#else
-   #define BOOST_CONTAINER_FALLTHOUGH BOOST_FALLTHOUGH;
-#endif
-
 #if defined(BOOST_MSVC) && (_MSC_VER < 1400)
    #define BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
 #endif
diff --git a/boost/container/flat_map.hpp b/boost/container/flat_map.hpp
index b842101..d87f7bd 100644
--- a/boost/container/flat_map.hpp
+++ b/boost/container/flat_map.hpp
@@ -30,6 +30,7 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/algorithm.hpp> //equal()
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
 // move
 #include <boost/move/utility_core.hpp>
 #include <boost/move/traits.hpp>
@@ -53,20 +54,21 @@ namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 class flat_multimap;
 
 namespace container_detail{
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D &force(const S &s)
-{  return *const_cast<D*>((reinterpret_cast<const D*>(&s))); }
+BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
+{  return *reinterpret_cast<D*>(&s); }
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D force_copy(S s)
+BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 {
-   D *vp = reinterpret_cast<D *>(&s);
-   return D(*vp);
+   const D *const vp = reinterpret_cast<const D *>(&s);
+   D ret_val(*vp);
+   return ret_val;
 }
 
 }  //namespace container_detail{
@@ -75,37 +77,37 @@ BOOST_CONTAINER_FORCEINLINE static D force_copy(S s)
 
 //! A flat_map is a kind of associative container that supports unique keys (contains at
 //! most one of each key value) and provides for fast retrieval of values of another
-//! type T based on the keys. The flat_map class supports random-access iterators.
+//! type T based on the keys.
 //!
-//! A flat_map satisfies all of the requirements of a container and of a reversible
-//! container and of an associative container. A flat_map also provides
+//! A flat_map satisfies all of the requirements of a container, a reversible
+//! container and an associative container. A flat_map also provides
 //! most operations described for unique keys. For a
 //! flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::map<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
-//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
+//! flat_map is similar to std::map but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! Allocator is the allocator to allocate the value_types
-//! (e.g. <i>allocator< std::pair<Key, T> ></i>).
-//!
-//! flat_map is similar to std::map but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_map invalidates
-//! previous iterators and references
-//!
-//! Erasing an element invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_map might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the key_type of the map
 //! \tparam Value is the <code>mapped_type</code>
 //! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
-//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s
-//!   (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators..
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Compare = std::less<Key>, class Allocator = new_allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator< std::pair< Key, T> > >
 #else
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 #endif
 class flat_map
 {
@@ -117,43 +119,50 @@ class flat_map
                            std::pair<Key, T>,
                            container_detail::select1st<Key>,
                            Compare,
-                           Allocator> tree_t;
+                           AllocatorOrContainer> tree_t;
 
    //This is the real tree stored here. It's based on a movable pair
    typedef container_detail::flat_tree<
                            container_detail::pair<Key, T>,
                            container_detail::select1st<Key>,
                            Compare,
-                           typename allocator_traits<Allocator>::template portable_rebind_alloc
-                              <container_detail::pair<Key, T> >::type> impl_tree_t;
+                           typename container_detail::container_or_allocator_rebind<AllocatorOrContainer, container_detail::pair<Key, T> >::type
+                           > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
    typedef typename impl_tree_t::value_type              impl_value_type;
    typedef typename impl_tree_t::const_iterator          impl_const_iterator;
    typedef typename impl_tree_t::iterator                impl_iterator;
    typedef typename impl_tree_t::allocator_type          impl_allocator_type;
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   typedef std::initializer_list<impl_value_type>        impl_initializer_list;
+   #endif
+
    typedef container_detail::flat_tree_value_compare
       < Compare
       , container_detail::select1st<Key>
-      , std::pair<Key, T> >                                                         value_compare_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::iterator                  iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-      <typename allocator_traits<Allocator>::pointer>::const_iterator               const_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::reverse_iterator          reverse_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
+      , std::pair<Key, T> >                              value_compare_t;
+   typedef typename tree_t::iterator                     iterator_t;
+   typedef typename tree_t::const_iterator               const_iterator_t;
+   typedef typename tree_t::reverse_iterator             reverse_iterator_t;
+   typedef typename tree_t::const_reverse_iterator       const_reverse_iterator_t;
+
    public:
    typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type           impl_sequence_type;
 
-   impl_tree_t &tree()
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
+   typedef typename tree_t::get_stored_allocator_const_return_t         get_stored_allocator_const_return_t;
+   typedef typename tree_t::get_stored_allocator_noconst_return_t       get_stored_allocator_noconst_return_t;
+   typedef typename impl_tree_t::get_stored_allocator_const_return_t    impl_get_stored_allocator_const_return_t;
+   typedef typename impl_tree_t::get_stored_allocator_noconst_return_t  impl_get_stored_allocator_noconst_return_t;
+
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -165,25 +174,29 @@ class flat_map
    //////////////////////////////////////////////
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<Key, T>                                                        value_type;
-   typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
-   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
-   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
-   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
-   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
-   typedef Allocator                                                                allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(Allocator)                                        stored_allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
    typedef Compare                                                                  key_compare;
-   typedef BOOST_CONTAINER_IMPDEF(iterator_impl)                                    iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl)                              const_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
+   typedef std::pair<Key, T>                                                        value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
 
-   public:
+   //AllocatorOrContainer::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename allocator_type::value_type>::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -193,106 +206,200 @@ class flat_map
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_map()  BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                 container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_map() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                                            container_detail::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const allocator_type& a)
+      : m_flat_tree(container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified
+   //! comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! comparison object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit flat_map(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : m_flat_tree(true, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last)
+      : m_flat_tree(true, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(true, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const allocator_type& a)
+      : m_flat_tree(true, first, last, container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the ordered unique range [first ,last). This function
+   //! and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(true, first, last, comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map
+   //! and inserts elements from the ordered range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
-   //! unique values.
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
    //!
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
-           , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_unique_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(ordered_range, first, last, comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
-     : m_flat_tree(true, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il)
+     : m_flat_tree( true
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const allocator_type& a)
-     : m_flat_tree(true, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const allocator_type& a)
+     : m_flat_tree( true
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end()
+                  , container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(true
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end()
+                  , comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+     : m_flat_tree(true
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end()
+                  , comp
+                  , container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il)
+     : m_flat_tree(ordered_unique_range
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(ordered_unique_range
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end()
+                  , comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
@@ -304,24 +411,21 @@ class flat_map
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
-     : m_flat_tree(ordered_unique_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+     : m_flat_tree( ordered_unique_range
+                  , container_detail::force<impl_initializer_list>(il).begin()
+                  , container_detail::force<impl_initializer_list>(il).end()
+                  , comp
+                  , container_detail::force<const impl_allocator_type>(a))
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
@@ -329,39 +433,30 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_map(BOOST_RV_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x, const allocator_type &a)
-      : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x, const allocator_type &a)
+      : m_flat_tree(x.m_flat_tree, container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map using the specified allocator.
    //!   Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if x.get_allocator() == a, linear otherwise.
-   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
-      : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
+      : m_flat_tree(boost::move(x.m_flat_tree), container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
    {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Move constructs a flat_map.
@@ -373,7 +468,7 @@ class flat_map
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   flat_map& operator=(BOOST_RV_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_RV_REF(flat_map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -393,7 +488,7 @@ class flat_map
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
@@ -403,8 +498,11 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_noconst_return_t get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      impl_get_stored_allocator_noconst_return_t r = m_flat_tree.get_stored_allocator();
+      return container_detail::force<stored_allocator_type>(r);
+   }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
    //!
@@ -413,8 +511,11 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE get_stored_allocator_const_return_t get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      impl_get_stored_allocator_const_return_t r = m_flat_tree.get_stored_allocator();
+      return container_detail::force<const stored_allocator_type>(r);
+   }
 
    //////////////////////////////////////////////
    //
@@ -427,7 +528,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
@@ -435,7 +536,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
@@ -443,7 +544,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator end() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
@@ -451,7 +552,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@@ -460,7 +561,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -469,7 +570,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@@ -478,7 +579,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -487,7 +588,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
@@ -495,7 +596,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
@@ -503,7 +604,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -512,7 +613,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -521,7 +622,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //////////////////////////////////////////////
@@ -535,7 +636,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
@@ -543,7 +644,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
@@ -551,7 +652,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -560,10 +661,11 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
-   //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
+   //! <b>Effects</b>: If n is less than or equal to capacity(), or the
+   //!   underlying container has no `reserve` member, this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
@@ -572,7 +674,7 @@ class flat_map
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type cnt)
+   BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -581,7 +683,7 @@ class flat_map
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   void shrink_to_fit()
+   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //////////////////////////////////////////////
@@ -608,8 +710,8 @@ class flat_map
    mapped_type &operator[](key_type &&k) ;
    #elif defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
       //in compilers like GCC 3.4, we can't catch temporaries
-      mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
-      mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
    #else
       BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
    #endif
@@ -705,19 +807,19 @@ class flat_map
    }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
-   iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
-   const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
-   size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
-   size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
 
    //! Returns: A reference to the element whose key is equivalent to x.
@@ -769,7 +871,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
@@ -785,7 +887,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
@@ -869,14 +971,14 @@ class flat_map
 
    #define BOOST_CONTAINER_FLAT_MAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy< std::pair<iterator, bool> >\
          (m_flat_tree.emplace_unique(BOOST_MOVE_FWD##N));\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique\
          (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
@@ -921,9 +1023,9 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(const value_type& x)
    {  return container_detail::force_copy<std::pair<iterator,bool> >(
-         m_flat_tree.insert_unique(container_detail::force<impl_value_type>(x))); }
+         m_flat_tree.insert_unique(container_detail::force<const impl_value_type>(x))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
@@ -936,7 +1038,7 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    {  return container_detail::force_copy<std::pair<iterator,bool> >(
       m_flat_tree.insert_unique(boost::move(container_detail::force<impl_value_type>(x)))); }
 
@@ -951,7 +1053,7 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
    {
       return container_detail::force_copy<std::pair<iterator,bool> >
       (m_flat_tree.insert_unique(boost::move(x)));
@@ -968,11 +1070,11 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+                                  , container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts an element move constructed from x in the container.
@@ -984,7 +1086,7 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
@@ -1000,7 +1102,7 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_unique(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
@@ -1016,7 +1118,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  m_flat_tree.insert_unique(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1035,7 +1137,7 @@ class flat_map
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_unique(ordered_unique_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1046,8 +1148,11 @@ class flat_map
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_unique(il.begin(), il.end());  }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_unique( container_detail::force<impl_initializer_list>(il).begin()
+                               , container_detail::force<impl_initializer_list>(il).end());
+   }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
    //! unique values.
@@ -1062,8 +1167,12 @@ class flat_map
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_unique(ordered_unique_range, il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_unique(ordered_unique_range
+                               , container_detail::force<impl_initializer_list>(il).begin()
+                               , container_detail::force<impl_initializer_list>(il).end());
+   }
 #endif
 
    //! <b>Requires</b>: this->get_allocator() == source.get_allocator().
@@ -1081,23 +1190,23 @@ class flat_map
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_map<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multimap<Key, T, C2, Allocator>&>(source));  }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source));  }
 
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
@@ -1109,7 +1218,7 @@ class flat_map
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
@@ -1121,7 +1230,7 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1132,7 +1241,7 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
@@ -1144,7 +1253,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_map& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
@@ -1154,7 +1263,7 @@ class flat_map
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -1167,14 +1276,14 @@ class flat_map
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
       { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
       { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
@@ -1187,102 +1296,135 @@ class flat_map
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
       { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       {  return static_cast<size_type>(m_flat_tree.find(x) != m_flat_tree.end());  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator lower_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator lower_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator upper_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator upper_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.lower_bound_range(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
       {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.lower_bound_range(x)); }
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(container_detail::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment. Erases non-unique elements.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!   and shall contain unique elements.
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(ordered_unique_range_t(), boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_map& x, const flat_map& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_map& x, const flat_map& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_map& x, const flat_map& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_map& x, const flat_map& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_map& x, const flat_map& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_map& x, const flat_map& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_map& x, flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_map& x, flat_map& y)
    {  x.swap(y);  }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1317,11 +1459,11 @@ class flat_map
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class T, class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, Allocator> >
+template <class Key, class T, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
@@ -1332,37 +1474,36 @@ namespace container {
 
 //! A flat_multimap is a kind of associative container that supports equivalent keys
 //! (possibly containing multiple copies of the same key value) and provides for
-//! fast retrieval of values of another type T based on the keys. The flat_multimap
-//! class supports random-access iterators.
+//! fast retrieval of values of another type T based on the keys. 
 //!
 //! A flat_multimap satisfies all of the requirements of a container and of a reversible
 //! container and of an associative container. For a
 //! flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T>
 //! (unlike std::multimap<Key, T> which value_type is std::pair<<b>const</b> Key, T>).
 //!
-//! Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
+//! flat_multimap is similar to std::multimap but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! Allocator is the allocator to allocate the value_types
-//! (e.g. <i>allocator< std::pair<Key, T> ></i>).
-//!
-//! flat_multimap is similar to std::multimap but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_map invalidates
-//! previous iterators and references
-//!
-//! Erasing an element invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_multimap might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the key_type of the map
 //! \tparam Value is the <code>mapped_type</code>
 //! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>).
-//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s
-//!   (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class T, class Compare = std::less<Key>, class Allocator = new_allocator< std::pair< Key, T> > >
+template <class Key, class T, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator< std::pair< Key, T> > >
 #else
-template <class Key, class T, class Compare, class Allocator>
+template <class Key, class T, class Compare, class AllocatorOrContainer>
 #endif
 class flat_multimap
 {
@@ -1373,39 +1514,41 @@ class flat_multimap
                            std::pair<Key, T>,
                            container_detail::select1st<Key>,
                            Compare,
-                           Allocator> tree_t;
+                           AllocatorOrContainer> tree_t;
    //This is the real tree stored here. It's based on a movable pair
    typedef container_detail::flat_tree<
                            container_detail::pair<Key, T>,
                            container_detail::select1st<Key>,
                            Compare,
-                           typename allocator_traits<Allocator>::template portable_rebind_alloc
-                              <container_detail::pair<Key, T> >::type> impl_tree_t;
+                           typename container_detail::container_or_allocator_rebind<AllocatorOrContainer, container_detail::pair<Key, T> >::type
+                           > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
    typedef typename impl_tree_t::value_type              impl_value_type;
    typedef typename impl_tree_t::const_iterator          impl_const_iterator;
    typedef typename impl_tree_t::iterator                impl_iterator;
    typedef typename impl_tree_t::allocator_type          impl_allocator_type;
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   typedef std::initializer_list<impl_value_type>        impl_initializer_list;
+   #endif
+
    typedef container_detail::flat_tree_value_compare
       < Compare
       , container_detail::select1st<Key>
-      , std::pair<Key, T> >                                                         value_compare_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::iterator                  iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-      <typename allocator_traits<Allocator>::pointer>::const_iterator               const_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::reverse_iterator          reverse_iterator_impl;
-   typedef typename container_detail::get_flat_tree_iterators
-         <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
-   public:
-   typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+      , std::pair<Key, T> >                                 value_compare_t;
+   typedef typename tree_t::iterator                        iterator_t;
+   typedef typename tree_t::const_iterator                  const_iterator_t;
+   typedef typename tree_t::reverse_iterator                reverse_iterator_t;
+   typedef typename tree_t::const_reverse_iterator          const_reverse_iterator_t;
 
-   impl_tree_t &tree()
+   public:
+   typedef typename impl_tree_t::stored_allocator_type      impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type              impl_sequence_type;
+
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
@@ -1420,24 +1563,29 @@ class flat_multimap
    //////////////////////////////////////////////
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<Key, T>                                                        value_type;
-   typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
-   typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
-   typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
-   typedef typename boost::container::allocator_traits<Allocator>::const_reference  const_reference;
-   typedef typename boost::container::allocator_traits<Allocator>::size_type        size_type;
-   typedef typename boost::container::allocator_traits<Allocator>::difference_type  difference_type;
-   typedef Allocator                                                                allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(Allocator)                                        stored_allocator_type;
-   typedef BOOST_CONTAINER_IMPDEF(value_compare_impl)                               value_compare;
    typedef Compare                                                                  key_compare;
-   typedef BOOST_CONTAINER_IMPDEF(iterator_impl)                                    iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl)                              const_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
+   typedef std::pair<Key, T>                                                        value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
 
+   //AllocatorOrContainer::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename AllocatorOrContainer::value_type>::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -1447,63 +1595,109 @@ class flat_multimap
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_multimap() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                     container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_multimap()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const allocator_type& a)
+      : m_flat_tree(container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
+   //!   object .
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
    //!   object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const Compare& comp,
-                          const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
-   //!   and allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //!   and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_multimap(InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
-      : m_flat_tree(false, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last)
+      : m_flat_tree(false, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified
    //!   allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(false, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false, first, last, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(false, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(false, first, last, comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //! and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1515,39 +1709,93 @@ class flat_multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_flat_tree(ordered_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_multimap(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(false, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il)
+      : m_flat_tree( false
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(std::initializer_list<value_type> il, const allocator_type& a)
-      : m_flat_tree(false, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end()
+                   , container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree(false
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : m_flat_tree( false
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end()
+                   , comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il)
+      : m_flat_tree( ordered_range
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree( ordered_range
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function
@@ -1558,68 +1806,62 @@ class flat_multimap
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-                 const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : m_flat_tree( ordered_range
+                   , container_detail::force<impl_initializer_list>(il).begin()
+                   , container_detail::force<impl_initializer_list>(il).end()
+                   , comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap. Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x, const allocator_type &a)
-      : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(x.m_flat_tree, container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
-      : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(boost::move(x.m_flat_tree), container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_RV_REF(flat_multimap) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
@@ -1630,6 +1872,7 @@ class flat_multimap
    //! <b>Effects</b>: Assign content of il to *this
    //!
    //! <b>Complexity</b>: Linear in il.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(std::initializer_list<value_type> il)
    {
       this->clear();
@@ -1642,6 +1885,7 @@ class flat_multimap
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
@@ -1652,6 +1896,7 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
@@ -1662,8 +1907,9 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+      { return container_detail::force<const stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //////////////////////////////////////////////
    //
@@ -1676,6 +1922,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
@@ -1684,6 +1931,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
 
@@ -1692,6 +1940,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator end() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
@@ -1700,6 +1949,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
 
@@ -1709,6 +1959,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
@@ -1718,6 +1969,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
@@ -1727,6 +1979,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
@@ -1736,6 +1989,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
@@ -1744,6 +1998,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
@@ -1752,6 +2007,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
 
@@ -1761,6 +2017,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
@@ -1770,6 +2027,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
@@ -1784,6 +2042,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
@@ -1792,6 +2051,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
@@ -1800,6 +2060,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
@@ -1809,10 +2070,12 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
-   //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
+   //! <b>Effects</b>: If n is less than or equal to capacity(), or the
+   //!   underlying container has no `reserve` member, this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
@@ -1821,6 +2084,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
+   BOOST_CONTAINER_FORCEINLINE
    void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
@@ -1830,22 +2094,27 @@ class flat_multimap
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
+   BOOST_CONTAINER_FORCEINLINE
    void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
+   BOOST_CONTAINER_FORCEINLINE
    iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
 
@@ -1860,6 +2129,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
 
@@ -1876,6 +2146,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
@@ -1886,11 +2157,11 @@ class flat_multimap
 
    #define BOOST_CONTAINER_FLAT_MULTIMAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
    {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_MOVE_FWD##N));  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal\
          (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
@@ -1908,10 +2179,10 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const value_type& x)
    {
       return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_equal(container_detail::force<impl_value_type>(x)));
+         m_flat_tree.insert_equal(container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
@@ -1921,7 +2192,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(value_type) x)
    { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
@@ -1931,7 +2202,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(impl_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(impl_value_type) x)
       { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -1945,11 +2216,11 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+                                  , container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a value move constructed from x in the container.
@@ -1963,7 +2234,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p)
@@ -1981,7 +2252,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
@@ -1996,7 +2267,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(first, last); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -2014,7 +2285,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(ordered_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -2024,8 +2295,11 @@ class flat_multimap
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_equal(il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_equal( container_detail::force<impl_initializer_list>(il).begin()
+                              , container_detail::force<impl_initializer_list>(il).end());
+   }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
    //!
@@ -2039,8 +2313,12 @@ class flat_multimap
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_range_t, std::initializer_list<value_type> il)
-   {  m_flat_tree.insert_equal(ordered_range, il.begin(), il.end());  }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, std::initializer_list<value_type> il)
+   {
+      m_flat_tree.insert_equal( ordered_range
+                              , container_detail::force<impl_initializer_list>(il).begin()
+                              , container_detail::force<impl_initializer_list>(il).end());
+   }
 #endif
 
    //! <b>Requires</b>: this->get_allocator() == source.get_allocator().
@@ -2057,23 +2335,23 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   void merge(flat_multimap<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multimap<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multimap<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(flat_map<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, AllocatorOrContainer>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_map<Key, T, C2, Allocator>&>(source)); }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_map<Key, T, C2, AllocatorOrContainer>&>(source)); }
 
    //! <b>Effects</b>: Erases the element pointed to by p.
    //!
@@ -2085,7 +2363,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
@@ -2097,7 +2375,7 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -2108,7 +2386,7 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
@@ -2120,7 +2398,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_multimap& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_multimap& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
@@ -2130,7 +2408,7 @@ class flat_multimap
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -2143,14 +2421,14 @@ class flat_multimap
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
       { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
       { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
@@ -2163,102 +2441,134 @@ class flat_multimap
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: An const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
       { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       { return m_flat_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x));  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
       {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
       {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(container_detail::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare().
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(ordered_range_t(), boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_multimap& x, const flat_multimap& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_multimap& x, const flat_multimap& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_multimap& x, const flat_multimap& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_multimap& x, flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_multimap& x, flat_multimap& y)
    {  x.swap(y);  }
 };
 
@@ -2270,11 +2580,11 @@ namespace boost {
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class T, class Compare, class Allocator>
-struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, Allocator> >
+template <class Key, class T, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
diff --git a/boost/container/flat_set.hpp b/boost/container/flat_set.hpp
index fa27006..567fec9 100644
--- a/boost/container/flat_set.hpp
+++ b/boost/container/flat_set.hpp
@@ -48,45 +48,51 @@ namespace boost {
 namespace container {
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-template <class Key, class T, class Compare, class Allocator>
-class flat_multimap;
+template <class Key, class Compare, class AllocatorOrContainer>
+class flat_multiset;
 #endif
 
 //! flat_set is a Sorted Associative Container that stores objects of type Key.
 //! It is also a Unique Associative Container, meaning that no two elements are the same.
 //!
-//! flat_set is similar to std::set but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_set invalidates
-//! previous iterators and references
+//! flat_set is similar to std::set but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! Erasing an element of a flat_set invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_set might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the type to be inserted in the set, which is also the key_type
 //! \tparam Compare is the comparison functor used to order keys
-//! \tparam Allocator is the allocator to be used to allocate memory for this container
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class Compare = std::less<Key>, class Allocator = new_allocator<Key> >
+template <class Key, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator<Key> >
 #else
-template <class Key, class Compare, class Allocator>
+template <class Key, class Compare, class AllocatorOrContainer>
 #endif
 class flat_set
    ///@cond
-   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, Allocator>
+   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer>
    ///@endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_set)
-   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, Allocator> base_t;
+   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer> tree_t;
 
    public:
-   base_t &tree()
+   tree_t &tree()
    {  return *this;  }
 
-   const base_t &tree() const
+   const tree_t &tree() const
    {  return *this;  }
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -97,23 +103,25 @@ class flat_set
    //                    types
    //
    //////////////////////////////////////////////
-   typedef Key                                                                         key_type;
-   typedef Key                                                                         value_type;
-   typedef Compare                                                                     key_compare;
-   typedef Compare                                                                     value_compare;
-   typedef ::boost::container::allocator_traits<Allocator>                             allocator_traits_type;
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer           pointer;
-   typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer     const_pointer;
-   typedef typename ::boost::container::allocator_traits<Allocator>::reference         reference;
-   typedef typename ::boost::container::allocator_traits<Allocator>::const_reference   const_reference;
-   typedef typename ::boost::container::allocator_traits<Allocator>::size_type         size_type;
-   typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
-   typedef Allocator                                                                   allocator_type;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::stored_allocator_type)              stored_allocator_type;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::iterator)                           iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator)                     const_iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator)                   reverse_iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator)             const_reverse_iterator;
+   typedef Key                                                                      key_type;
+   typedef Compare                                                                  key_compare;
+   typedef Key                                                                      value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
 
    public:
    //////////////////////////////////////////////
@@ -125,25 +133,69 @@ class flat_set
    //! <b>Effects</b>: Default constructs an empty container.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                         container_detail::is_nothrow_default_constructible<Compare>::value)
-      : base_t()
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                container_detail::is_nothrow_default_constructible<Compare>::value)
+      : tree_t()
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified
+   //! comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
+   explicit flat_set(const Compare& comp)
+      : tree_t(comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
+   explicit flat_set(const allocator_type& a)
+      : tree_t(a)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified
    //! comparison object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_set(const Compare& comp,
-                     const allocator_type& a = allocator_type())
-      : base_t(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(const Compare& comp, const allocator_type& a)
+      : tree_t(comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty container using the specified allocator.
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the range [first ,last ).
    //!
-   //! <b>Complexity</b>: Constant.
-   explicit flat_set(const allocator_type& a)
-      : base_t(a)
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last)
+      : tree_t(true, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const allocator_type& a)
+      : tree_t(true, first, last, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const Compare& comp)
+      : tree_t(true, first, last, comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -152,20 +204,41 @@ class flat_set
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_set(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(true, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : tree_t(true, first, last, comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty container using the specified
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_set(InputIterator first, InputIterator last, const allocator_type& a)
-      : base_t(true, first, last, Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last)
+      : tree_t(ordered_unique_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : tree_t(ordered_unique_range, first, last, comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -179,21 +252,19 @@ class flat_set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(ordered_unique_range, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : tree_t(ordered_unique_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
    //! comp and otherwise N logN, where N is il.begin() - il.end().
-   flat_set(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il)
+      : tree_t(true, il.begin(), il.end())
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified
@@ -201,8 +272,54 @@ class flat_set
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
    //! comp and otherwise N logN, where N is il.begin() - il.end().
-   flat_set(std::initializer_list<value_type> il, const allocator_type& a)
-      : base_t(true, il.begin(), il.end(), Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const allocator_type& a)
+      : tree_t(true, il.begin(), il.end(), a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! comp and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const Compare& comp)
+      : tree_t(true, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! comp and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : tree_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il)
+      : tree_t(ordered_unique_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : tree_t(ordered_unique_range, il.begin(), il.end(), comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -215,17 +332,16 @@ class flat_set
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_set(ordered_unique_range_t, std::initializer_list<value_type> il,
-            const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(ordered_unique_range, il.begin(), il.end(), comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : tree_t(ordered_unique_range, il.begin(), il.end(), comp, a)
    {}
 #endif
 
    //! <b>Effects</b>: Copy constructs the container.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set(const flat_set& x)
-      : base_t(static_cast<const base_t&>(x))
+   BOOST_CONTAINER_FORCEINLINE flat_set(const flat_set& x)
+      : tree_t(static_cast<const tree_t&>(x))
    {}
 
    //! <b>Effects</b>: Move constructs thecontainer. Constructs *this using x's resources.
@@ -233,31 +349,31 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_set(BOOST_RV_REF(flat_set) x)
+   BOOST_CONTAINER_FORCEINLINE flat_set(BOOST_RV_REF(flat_set) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
-      : base_t(BOOST_MOVE_BASE(base_t, x))
+      : tree_t(BOOST_MOVE_BASE(tree_t, x))
    {}
 
    //! <b>Effects</b>: Copy constructs a container using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set(const flat_set& x, const allocator_type &a)
-      : base_t(static_cast<const base_t&>(x), a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(const flat_set& x, const allocator_type &a)
+      : tree_t(static_cast<const tree_t&>(x), a)
    {}
 
    //! <b>Effects</b>: Move constructs a container using the specified allocator.
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise
-   flat_set(BOOST_RV_REF(flat_set) x, const allocator_type &a)
-      : base_t(BOOST_MOVE_BASE(base_t, x), a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(BOOST_RV_REF(flat_set) x, const allocator_type &a)
+      : tree_t(BOOST_MOVE_BASE(tree_t, x), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
-   {  return static_cast<flat_set&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
+   BOOST_CONTAINER_FORCEINLINE flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
+   {  return static_cast<flat_set&>(this->tree_t::operator=(static_cast<const tree_t&>(x)));  }
 
    //! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment
    //!   is false and (allocation throws or value_type's move constructor throws)
@@ -265,11 +381,11 @@ class flat_set
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   flat_set& operator=(BOOST_RV_REF(flat_set) x)
+   BOOST_CONTAINER_FORCEINLINE flat_set& operator=(BOOST_RV_REF(flat_set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
-   {  return static_cast<flat_set&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
+   {  return static_cast<flat_set&>(this->tree_t::operator=(BOOST_MOVE_BASE(tree_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Copy all elements from il to *this.
@@ -427,12 +543,13 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW;
 
-   //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
+   //! <b>Effects</b>: If n is less than or equal to capacity(), or the
+   //!   underlying container has no `reserve` member, this call has no
    //!   effect. Otherwise, it is a request for allocation of additional memory.
    //!   If the request is successful, then capacity() is greater than or equal to
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
    //!
-   //! <b>Throws</b>: If memory allocation allocation throws or Key's copy constructor throws.
+   //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws.
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
@@ -469,8 +586,8 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
-   {  return this->base_t::emplace_unique(boost::forward<Args>(args)...); }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   {  return this->tree_t::emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
    //!   std::forward<Args>(args)... in the container if and only if there is
@@ -485,19 +602,19 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
-   {  return this->base_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   {  return this->tree_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_SET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
-   {  return this->base_t::emplace_unique(BOOST_MOVE_FWD##N);  }\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   {  return this->tree_t::emplace_unique(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {  return this->base_t::emplace_hint_unique(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {  return this->tree_t::emplace_hint_unique(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_SET_EMPLACE_CODE)
    #undef BOOST_CONTAINER_FLAT_SET_EMPLACE_CODE
@@ -575,8 +692,8 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
-      {  this->base_t::insert_unique(first, last);  }
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
+      {  this->tree_t::insert_unique(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
    //! must be ordered according to the predicate and must be
@@ -590,8 +707,8 @@ class flat_set
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
-      {  this->base_t::insert_unique(ordered_unique_range, first, last);  }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+      {  this->tree_t::insert_unique(ordered_unique_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) if and only
@@ -601,8 +718,8 @@ class flat_set
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  this->base_t::insert_unique(il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {  this->tree_t::insert_unique(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate
    //! and must be unique values.
@@ -614,29 +731,29 @@ class flat_set
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
-   void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
-   {  this->base_t::insert_unique(ordered_unique_range, il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
+   {  this->tree_t::insert_unique(ordered_unique_range, il.begin(), il.end()); }
 #endif
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_set<Key, C2, Allocator>& source)
-   {  this->base_t::merge_unique(source.tree());   }
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_set<Key, C2, AllocatorOrContainer>& source)
+   {  this->tree_t::merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_set<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_set::merge(flat_set<Key, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_set<Key, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_set<Key, C2, Allocator>&>(source));   }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_set<Key, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_set<Key, C2, AllocatorOrContainer>&>(source));   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_map::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_multiset<Key, C2, Allocator>& source)
-   {  this->base_t::merge_unique(source.tree());   }
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multiset<Key, C2, AllocatorOrContainer>& source)
+   {  this->tree_t::merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_multiset<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_set::merge(flat_multiset<Key, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multiset<Key, C2, Allocator>&>(source));   }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multiset<Key, C2, AllocatorOrContainer>&>(source));   }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -765,8 +882,8 @@ class flat_set
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
-   {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend());  }
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
+   {  return static_cast<size_type>(this->tree_t::find(x) != this->tree_t::cend());  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
@@ -798,14 +915,14 @@ class flat_set
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
-   {  return this->base_t::lower_bound_range(x);  }
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+   {  return this->tree_t::lower_bound_range(x);  }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
-   {  return this->base_t::lower_bound_range(x);  }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
+   {  return this->tree_t::lower_bound_range(x);  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -844,17 +961,47 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    friend void swap(flat_set& x, flat_set& y);
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   sequence_type extract_sequence();
+
    #endif   //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment. Erases non-unique elements.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->tree_t::adopt_sequence_unique(boost::move(seq));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!   and shall contain unique elements.
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->tree_t::adopt_sequence_unique(ordered_unique_range_t(), boost::move(seq));  }
+
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template<class KeyType>
-   std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
-   {  return this->base_t::insert_unique(::boost::forward<KeyType>(x));  }
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+   {  return this->tree_t::insert_unique(::boost::forward<KeyType>(x));  }
 
    template<class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
-   {  return this->base_t::insert_unique(p, ::boost::forward<KeyType>(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   {  return this->tree_t::insert_unique(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
@@ -864,11 +1011,11 @@ class flat_set
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::flat_set<Key, Compare, Allocator> >
+template <class Key, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move<boost::container::flat_set<Key, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
@@ -877,42 +1024,47 @@ namespace container {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-//! flat_multiset is a Sorted Associative Container that stores objects of type Key.
+//! flat_multiset is a Sorted Associative Container that stores objects of type Key and
+//! can store multiple copies of the same key value.
 //!
-//! flat_multiset can store multiple copies of the same key value.
+//! flat_multiset is similar to std::multiset but it's implemented by as an ordered sequence container.
+//! The underlying sequence container is by default <i>vector</i> but it can also work
+//! user-provided vector-like SequenceContainers (like <i>static_vector</i> or <i>small_vector</i>).
 //!
-//! flat_multiset is similar to std::multiset but it's implemented like an ordered vector.
-//! This means that inserting a new element into a flat_multiset invalidates
-//! previous iterators and references
-//!
-//! Erasing an element invalidates iterators and references
-//! pointing to elements that come after (their keys are bigger) the erased element.
+//! Using vector-like sequence containers means that inserting a new element into a flat_multiset might invalidate
+//! previous iterators and references (unless that sequence container is <i>stable_vector</i> or a similar
+//! container that offers stable pointers and references). Similarly, erasing an element might invalidate
+//! iterators and references pointing to elements that come after (their keys are bigger) the erased element.
 //!
 //! This container provides random-access iterators.
 //!
 //! \tparam Key is the type to be inserted in the multiset, which is also the key_type
 //! \tparam Compare is the comparison functor used to order keys
-//! \tparam Allocator is the allocator to be used to allocate memory for this container
+//! \tparam AllocatorOrContainer is either:
+//!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
+//!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
+//!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
+//!     sequence container with random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-template <class Key, class Compare = std::less<Key>, class Allocator = new_allocator<Key> >
+template <class Key, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator<Key> >
 #else
-template <class Key, class Compare, class Allocator>
+template <class Key, class Compare, class AllocatorOrContainer>
 #endif
 class flat_multiset
    ///@cond
-   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, Allocator>
+   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer>
    ///@endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
-   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, Allocator> base_t;
+   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer> tree_t;
 
    public:
-   base_t &tree()
+   tree_t &tree()
    {  return *this;  }
 
-   const base_t &tree() const
+   const tree_t &tree() const
    {  return *this;  }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -922,57 +1074,73 @@ class flat_multiset
    //                    types
    //
    //////////////////////////////////////////////
-   typedef Key                                                                         key_type;
-   typedef Key                                                                         value_type;
-   typedef Compare                                                                     key_compare;
-   typedef Compare                                                                     value_compare;
-   typedef ::boost::container::allocator_traits<Allocator>                             allocator_traits_type;
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer           pointer;
-   typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer     const_pointer;
-   typedef typename ::boost::container::allocator_traits<Allocator>::reference         reference;
-   typedef typename ::boost::container::allocator_traits<Allocator>::const_reference   const_reference;
-   typedef typename ::boost::container::allocator_traits<Allocator>::size_type         size_type;
-   typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
-   typedef Allocator                                                                   allocator_type;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::stored_allocator_type)              stored_allocator_type;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::iterator)                           iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator)                     const_iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator)                   reverse_iterator;
-   typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator)             const_reverse_iterator;
+   typedef Key                                                                      key_type;
+   typedef Compare                                                                  key_compare;
+   typedef Key                                                                      value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+   typedef typename sequence_type::allocator_type                                   allocator_type;
+   typedef ::boost::container::allocator_traits<allocator_type>                     allocator_traits_type;
+   typedef typename sequence_type::pointer                                          pointer;
+   typedef typename sequence_type::const_pointer                                    const_pointer;
+   typedef typename sequence_type::reference                                        reference;
+   typedef typename sequence_type::const_reference                                  const_reference;
+   typedef typename sequence_type::size_type                                        size_type;
+   typedef typename sequence_type::difference_type                                  difference_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::stored_allocator_type)           stored_allocator_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::value_compare)                   value_compare;
+
+   typedef typename sequence_type::iterator                                         iterator;
+   typedef typename sequence_type::const_iterator                                   const_iterator;
+   typedef typename sequence_type::reverse_iterator                                 reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
 
    //! @copydoc ::boost::container::flat_set::flat_set()
-   explicit flat_multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                              container_detail::is_nothrow_default_constructible<Compare>::value)
-      : base_t()
+   BOOST_CONTAINER_FORCEINLINE flat_multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                                                 container_detail::is_nothrow_default_constructible<Compare>::value)
+      : tree_t()
    {}
 
-   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&, const allocator_type&)
-   explicit flat_multiset(const Compare& comp,
-                          const allocator_type& a = allocator_type())
-      : base_t(comp, a)
+   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multiset(const Compare& comp)
+      : tree_t(comp)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(const allocator_type&)
-   explicit flat_multiset(const allocator_type& a)
-      : base_t(a)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multiset(const allocator_type& a)
+      : tree_t(a)
    {}
 
-   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const Compare& comp, const allocator_type& a)
+      : tree_t(comp, a)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator)
    template <class InputIterator>
-   flat_multiset(InputIterator first, InputIterator last,
-                 const Compare& comp        = Compare(),
-                 const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last)
+      : tree_t(false, first, last)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const allocator_type&)
    template <class InputIterator>
-   flat_multiset(InputIterator first, InputIterator last, const allocator_type& a)
-      : base_t(false, first, last, Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const allocator_type& a)
+      : tree_t(false, first, last, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
-   //! allocator, and inserts elements from the ordered range [first ,last ). This function
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const Compare& comp)
+      : tree_t(false, first, last, comp)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : tree_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset and
+   //! inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
@@ -981,22 +1149,83 @@ class flat_multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
-                 const Compare& comp        = Compare(),
-                 const allocator_type& a = allocator_type())
-      : base_t(ordered_range, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last)
+      : tree_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : tree_t(ordered_range, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
+   //! allocator, and inserts elements from the ordered range [first, last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : tree_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   flat_multiset(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il)
+      : tree_t(false, il.begin(), il.end())
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const allocator_type&)
-   flat_multiset(std::initializer_list<value_type> il, const allocator_type& a)
-      : base_t(false, il.begin(), il.end(), Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const allocator_type& a)
+      : tree_t(false, il.begin(), il.end(), a)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const Compare& comp)
+      : tree_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : tree_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty containerand
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il)
+      : tree_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : tree_t(ordered_range, il.begin(), il.end(), comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -1008,43 +1237,42 @@ class flat_multiset
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_multiset(ordered_range_t, std::initializer_list<value_type> il,
-            const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(ordered_range, il.begin(), il.end(), comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : tree_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
 
    //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &)
-   flat_multiset(const flat_multiset& x)
-      : base_t(static_cast<const base_t&>(x))
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const flat_multiset& x)
+      : tree_t(static_cast<const tree_t&>(x))
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&)
-   flat_multiset(BOOST_RV_REF(flat_multiset) x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(BOOST_RV_REF(flat_multiset) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
-      : base_t(boost::move(static_cast<base_t&>(x)))
+      : tree_t(boost::move(static_cast<tree_t&>(x)))
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &, const allocator_type &)
-   flat_multiset(const flat_multiset& x, const allocator_type &a)
-      : base_t(static_cast<const base_t&>(x), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const flat_multiset& x, const allocator_type &a)
+      : tree_t(static_cast<const tree_t&>(x), a)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&, const allocator_type &)
-   flat_multiset(BOOST_RV_REF(flat_multiset) x, const allocator_type &a)
-      : base_t(BOOST_MOVE_BASE(base_t, x), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(BOOST_RV_REF(flat_multiset) x, const allocator_type &a)
+      : tree_t(BOOST_MOVE_BASE(tree_t, x), a)
    {}
 
    //! @copydoc ::boost::container::flat_set::operator=(const flat_set &)
-   flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
-   {  return static_cast<flat_multiset&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
+   BOOST_CONTAINER_FORCEINLINE flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
+   {  return static_cast<flat_multiset&>(this->tree_t::operator=(static_cast<const tree_t&>(x)));  }
 
    //! @copydoc ::boost::container::flat_set::operator=(flat_set &&)
-   flat_multiset& operator=(BOOST_RV_REF(flat_multiset) x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset& operator=(BOOST_RV_REF(flat_multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
-   {  return static_cast<flat_multiset&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
+   {  return static_cast<flat_multiset&>(this->tree_t::operator=(BOOST_MOVE_BASE(tree_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! @copydoc ::boost::container::flat_set::operator=(std::initializer_list<value_type>)
@@ -1140,8 +1368,8 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace(BOOST_FWD_REF(Args)... args)
-   {  return this->base_t::emplace_equal(boost::forward<Args>(args)...); }
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_FWD_REF(Args)... args)
+   {  return this->tree_t::emplace_equal(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
    //!   std::forward<Args>(args)... in the container.
@@ -1155,19 +1383,19 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
-   {  return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   {  return this->tree_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_MULTISET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
-   {  return this->base_t::emplace_equal(BOOST_MOVE_FWD##N);  }\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
+   {  return this->tree_t::emplace_equal(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {  return this->base_t::emplace_hint_equal(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {  return this->tree_t::emplace_hint_equal(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_MULTISET_EMPLACE_CODE)
    #undef BOOST_CONTAINER_FLAT_MULTISET_EMPLACE_CODE
@@ -1233,8 +1461,8 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
-      {  this->base_t::insert_equal(first, last);  }
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
+      {  this->tree_t::insert_equal(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
    //! must be ordered according to the predicate.
@@ -1247,8 +1475,8 @@ class flat_multiset
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(ordered_range_t, InputIterator first, InputIterator last)
-      {  this->base_t::insert_equal(ordered_range, first, last);  }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, InputIterator first, InputIterator last)
+      {  this->tree_t::insert_equal(ordered_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()).
@@ -1257,8 +1485,8 @@ class flat_multiset
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
-   {  this->base_t::insert_equal(il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   {  this->tree_t::insert_equal(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate.
    //!
@@ -1269,29 +1497,29 @@ class flat_multiset
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
-   void insert(ordered_range_t, std::initializer_list<value_type> il)
-   {  this->base_t::insert_equal(ordered_range, il.begin(), il.end()); }
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, std::initializer_list<value_type> il)
+   {  this->tree_t::insert_equal(ordered_range, il.begin(), il.end()); }
 #endif
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_multiset<Key, C2, Allocator>& source)
-   {  this->base_t::merge_equal(source.tree());   }
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multiset<Key, C2, AllocatorOrContainer>& source)
+   {  this->tree_t::merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multiset::merge(flat_multiset<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multiset::merge(flat_multiset<Key, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_multiset<Key, C2, Allocator>&>(source));   }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_multiset<Key, C2, AllocatorOrContainer>&>(source));   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_map<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_map<Key, T, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(flat_set<Key, C2, Allocator>& source)
-   {  this->base_t::merge_equal(source.tree());   }
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_set<Key, C2, AllocatorOrContainer>& source)
+   {  this->tree_t::merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multiset::merge(flat_set<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multiset::merge(flat_set<Key, C2, AllocatorOrContainer>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_set<Key, C2, Allocator> BOOST_RV_REF_END source)
-   {  return this->merge(static_cast<flat_set<Key, C2, Allocator>&>(source));   }
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_set<Key, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
+   {  return this->merge(static_cast<flat_set<Key, C2, AllocatorOrContainer>&>(source));   }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -1392,17 +1620,46 @@ class flat_multiset
    //! <b>Complexity</b>: Constant.
    friend void swap(flat_multiset& x, flat_multiset& y);
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   sequence_type extract_sequence();
+
    #endif   //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->tree_t::adopt_sequence_equal(boost::move(seq));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->tree_t::adopt_sequence_equal(ordered_range_t(), boost::move(seq));  }
+
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   iterator priv_insert(BOOST_FWD_REF(KeyType) x)
-   {  return this->base_t::insert_equal(::boost::forward<KeyType>(x));  }
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+   {  return this->tree_t::insert_equal(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
-   {  return this->base_t::insert_equal(p, ::boost::forward<KeyType>(x)); }
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   {  return this->tree_t::insert_equal(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
@@ -1412,11 +1669,11 @@ class flat_multiset
 
 //!has_trivial_destructor_after_move<> == true_type
 //!specialization for optimizations
-template <class Key, class Compare, class Allocator>
-struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, Compare, Allocator> >
+template <class Key, class Compare, class AllocatorOrContainer>
+struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, Compare, AllocatorOrContainer> >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::allocator_traits<AllocatorOrContainer>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<AllocatorOrContainer>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
diff --git a/boost/container/map.hpp b/boost/container/map.hpp
index 5520fb4..33e0331 100644
--- a/boost/container/map.hpp
+++ b/boost/container/map.hpp
@@ -31,6 +31,8 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/pair.hpp>
+#include <boost/container/detail/pair_key_mapped_of_value.hpp>
+
 // move
 #include <boost/move/traits.hpp>
 #include <boost/move/utility_core.hpp>
@@ -53,34 +55,6 @@
 namespace boost {
 namespace container {
 
-///@cond
-
-template<class Key, class Mapped>
-struct pair_key_mapped_of_value
-{
-   typedef Key    key_type;
-   typedef Mapped mapped_type;
-
-   template<class Pair>
-   const key_type & key_of_value(const Pair &p) const
-   {  return p.first;  }
-
-   template<class Pair>
-   const mapped_type & mapped_of_value(const Pair &p) const
-   {  return p.second;  }
-
-   template<class Pair>
-   key_type & key_of_value(Pair &p) const
-   {  return const_cast<key_type&>(p.first);  }
-
-   template<class Pair>
-   mapped_type & mapped_of_value(Pair &p) const
-   {  return p.second;  }
-
-};
-
-///@endcond
-
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! A map is a kind of associative container that supports unique keys (contains at
@@ -132,7 +106,7 @@ class map
    typedef Key                                                                      key_type;
    typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<const Key, T>                                                  value_type;
+   typedef typename boost::container::allocator_traits<Allocator>::value_type       value_type;
    typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
    typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
    typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
@@ -150,14 +124,15 @@ class map
    typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
    typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;
    typedef BOOST_CONTAINER_IMPDEF(node_handle<
-      typename base_t::node_type::container_node_type
-      BOOST_MOVE_I value_type
-      BOOST_MOVE_I allocator_type
+      typename base_t::stored_allocator_type
       BOOST_MOVE_I pair_key_mapped_of_value
          <key_type BOOST_MOVE_I mapped_type> >)                                     node_type;
    typedef BOOST_CONTAINER_IMPDEF
       (insert_return_type_base<iterator BOOST_MOVE_I node_type>)                    insert_return_type;
 
+   //allocator_type::value_type type must be std::pair<CONST Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -171,62 +146,99 @@ class map
    map() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
                            container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object
    //! and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE 
-   explicit map(const Compare& comp, const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit map(const Compare& comp)
+      : base_t(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE 
-   explicit map(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit map(const allocator_type& a)
       : base_t(a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : base_t(true, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last)
+      : base_t(true, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified 
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(true, first, last, Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(true, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
@@ -239,43 +251,76 @@ class map
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map( ordered_unique_range_t, InputIterator first, InputIterator last
-      , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last
+      , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted according
+   //! to the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il)
+      : base_t(true, il.begin(), il.end())
+   {}
+
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(true, il.begin(), il.end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and inserts elements from the ordered unique range [il.begin(), il.end()).
+   //! This function is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE map(ordered_unique_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object,
+   //!  and inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
@@ -285,51 +330,36 @@ class map
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-       const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, std::initializer_list<value_type> il
+                                  , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {} 
+
 #endif
 
    //! <b>Effects</b>: Copy constructs a map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(const map& x)
+   BOOST_CONTAINER_FORCEINLINE map(const map& x)
       : base_t(static_cast<const base_t&>(x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a map. Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(BOOST_RV_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map(BOOST_RV_REF(map) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(const map& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE map(const map& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a map using the specified allocator.
    //!                 Constructs *this using x's resources.
@@ -337,19 +367,14 @@ class map
    //! <b>Complexity</b>: Constant if x == x.get_allocator(), linear otherwise.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(BOOST_RV_REF(map) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE map(BOOST_RV_REF(map) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
    {  return static_cast<map&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! <b>Effects</b>: this->swap(x.get()).
@@ -360,8 +385,7 @@ class map
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(BOOST_RV_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(BOOST_RV_REF(map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -370,8 +394,7 @@ class map
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Assign content of il to *this.
    //!
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(std::initializer_list<value_type> il)
    {
        this->clear();
        insert(il.begin(), il.end());
@@ -716,7 +739,7 @@ class map
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x)
    { return this->try_emplace(p, boost::move(x.first), boost::move(x.second)); }
 
    //! <b>Effects</b>: Move constructs a new value from x if and only if there is
@@ -728,7 +751,7 @@ class map
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
    { return this->try_emplace(p, boost::move(x.first), boost::move(x.second)); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -746,7 +769,7 @@ class map
    //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    { return this->base_t::insert_unique(p, boost::move(x)); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1225,7 +1248,7 @@ class multimap
 
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<const Key, T>                                                  value_type;
+   typedef typename boost::container::allocator_traits<Allocator>::value_type       value_type;
    typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
    typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
    typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
@@ -1243,12 +1266,13 @@ class multimap
    typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
    typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;
    typedef BOOST_CONTAINER_IMPDEF(node_handle<
-      typename base_t::node_type::container_node_type
-      BOOST_MOVE_I value_type
-      BOOST_MOVE_I allocator_type
+      typename base_t::stored_allocator_type
       BOOST_MOVE_I pair_key_mapped_of_value
          <key_type BOOST_MOVE_I mapped_type> >)                                     node_type;
 
+   //allocator_type::value_type type must be std::pair<CONST Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -1258,66 +1282,102 @@ class multimap
    //! <b>Effects</b>: Default constructs an empty multimap.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   multimap() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE multimap()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty multimap using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   explicit multimap(const Compare& comp, const allocator_type& a = allocator_type())
-      : base_t(comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison
+   //! <b>Effects</b>: Constructs an empty multimap using the specified allocator
    //!   object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   explicit multimap(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit multimap(const allocator_type& a)
       : base_t(a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
-   //!   and allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit multimap(const Compare& comp)
+      : base_t(comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison and allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE multimap(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last)
+      : base_t(false, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified 
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
    BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(false, first, last, Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(false, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
+   //!   and allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last,
+            const Compare& comp, const allocator_type& a)
+      : base_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1329,41 +1389,51 @@ class multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp,
+         const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-           const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il)
+      : base_t(false, il.begin(), il.end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(false, il.begin(), il.end(), Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
@@ -1371,14 +1441,36 @@ class multimap
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-       const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
 #endif
 
    //! <b>Effects</b>: Copy constructs a multimap.
@@ -1386,10 +1478,7 @@ class multimap
    //! <b>Complexity</b>: Linear in x.size().
    BOOST_CONTAINER_FORCEINLINE multimap(const multimap& x)
       : base_t(static_cast<const base_t&>(x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a multimap. Constructs *this using x's resources.
    //!
@@ -1399,20 +1488,14 @@ class multimap
    BOOST_CONTAINER_FORCEINLINE multimap(BOOST_RV_REF(multimap) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    BOOST_CONTAINER_FORCEINLINE multimap(const multimap& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
@@ -1421,10 +1504,7 @@ class multimap
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE multimap(BOOST_RV_REF(multimap) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
@@ -1708,7 +1788,7 @@ class multimap
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   void merge(multimap<Key, T, C2, Allocator, Options>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(multimap<Key, T, C2, Allocator, Options>& source)
    {
       typedef container_detail::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
@@ -1717,12 +1797,12 @@ class multimap
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG multimap<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG multimap<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<multimap<Key, T, C2, Allocator, Options>&>(source)); }
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(map<Key, T, C2, Allocator, Options>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(map<Key, T, C2, Allocator, Options>& source)
    {
       typedef container_detail::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
@@ -1731,7 +1811,7 @@ class multimap
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG map<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG map<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<map<Key, T, C2, Allocator, Options>&>(source)); }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
diff --git a/boost/container/node_handle.hpp b/boost/container/node_handle.hpp
index c46313c..594a09c 100644
--- a/boost/container/node_handle.hpp
+++ b/boost/container/node_handle.hpp
@@ -23,7 +23,7 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 
@@ -40,20 +40,34 @@ namespace container {
 
 ///@cond
 
-template<class Value, class KeyMapped, bool keymapped_is_void = container_detail::is_same<KeyMapped, void>::value>
+template<class Value, class KeyMapped>
 struct node_handle_keymapped_traits
+{
+   typedef typename KeyMapped::key_type      key_type;
+   typedef typename KeyMapped::mapped_type   mapped_type;
+};
+
+template<class Value>
+struct node_handle_keymapped_traits<Value, void>
 {
    typedef Value key_type;
    typedef Value mapped_type;
 };
 
-template<class Value, class KeyMapped>
-struct node_handle_keymapped_traits<Value, KeyMapped, false>
+class node_handle_friend
 {
-   typedef typename KeyMapped::key_type      key_type;
-   typedef typename KeyMapped::mapped_type   mapped_type;
+   public:
+
+   template<class NH>
+   BOOST_CONTAINER_FORCEINLINE static void destroy_alloc(NH &nh) BOOST_NOEXCEPT
+   {  nh.destroy_alloc();  }
+
+   template<class NH>
+   BOOST_CONTAINER_FORCEINLINE static typename NH::node_pointer &get_node_pointer(NH &nh) BOOST_NOEXCEPT
+   {  return nh.get_node_pointer();  }
 };
 
+
 ///@endcond
 
 //! A node_handle is an object that accepts ownership of a single element from an associative container.
@@ -73,76 +87,63 @@ struct node_handle_keymapped_traits<Value, KeyMapped, false>
 //! 
 //! If a node handle is not empty, then it contains an allocator that is equal to the allocator of the container
 //! when the element was extracted. If a node handle is empty, it contains no allocator.
-template <class NodeType, class Value, class Allocator, class KeyMapped = void>
+template <class NodeAllocator, class KeyMapped = void>
 class node_handle
 {
-   typedef node_handle_keymapped_traits<Value, KeyMapped> keymapped_t;
+   typedef NodeAllocator                                          nallocator_type;
+   typedef allocator_traits<NodeAllocator>                        nator_traits;
+   typedef typename nator_traits::value_type                      priv_node_t;
+   typedef typename priv_node_t::value_type                       priv_value_t;
+   typedef node_handle_keymapped_traits<priv_value_t, KeyMapped>  keymapped_t;
 
    public:
-   typedef Value                                                  value_type;
+   typedef priv_value_t                                           value_type;
    typedef typename keymapped_t::key_type                         key_type;
    typedef typename keymapped_t::mapped_type                      mapped_type;
-   typedef Allocator                                              allocator_type;
-   typedef NodeType                                               container_node_type;
+   typedef typename nator_traits::template portable_rebind_alloc
+      <value_type>::type                                          allocator_type;
+
+   typedef priv_node_t                                            container_node_type;
+   friend class node_handle_friend;
 
    ///@cond
    private:
    BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle)
 
-   typedef allocator_traits<allocator_type>                                   ator_traits;
-   typedef typename ator_traits::template portable_rebind_alloc
-      <container_node_type>::type                                             nallocator_type;
-   typedef allocator_traits<nallocator_type>                                  node_ator_traits;
-   typedef typename node_ator_traits::pointer                                 node_pointer;
+   typedef typename nator_traits::pointer                         node_pointer;
    typedef ::boost::aligned_storage
-      <sizeof(allocator_type), boost::alignment_of<nallocator_type>::value>   nalloc_storage_t;
+      < sizeof(nallocator_type)
+      , boost::alignment_of<nallocator_type>::value>              nalloc_storage_t;
 
    node_pointer      m_ptr;
    nalloc_storage_t  m_nalloc_storage;
 
    void move_construct_alloc(nallocator_type &al)
-   {  ::new(m_nalloc_storage.address(), boost_container_new_t()) allocator_type(::boost::move(al));   }
+   {  ::new(m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(al));   }
 
-   void destroy_node()
+   void destroy_deallocate_node()
    {
-      node_ator_traits::destroy(this->node_alloc(), container_detail::to_raw_pointer(m_ptr));
-      node_ator_traits::deallocate(this->node_alloc(), m_ptr, 1u);
+      nator_traits::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(m_ptr));
+      nator_traits::deallocate(this->node_alloc(), m_ptr, 1u);
    }
 
    template<class OtherNodeHandle>
    void move_construct_end(OtherNodeHandle &nh)
    {
       if(m_ptr){
-         ::new (m_nalloc_storage.address(), boost_container_new_t()) allocator_type(::boost::move(nh.node_alloc()));
-         nh.destroy_alloc();
-         nh.get_node_pointer() = node_pointer();
+         ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
+         node_handle_friend::destroy_alloc(nh);
+         node_handle_friend::get_node_pointer(nh) = node_pointer();
       }
       BOOST_ASSERT(nh.empty());
    }
 
-   public:
+   void destroy_alloc() BOOST_NOEXCEPT
+   {  static_cast<nallocator_type*>(m_nalloc_storage.address())->~nallocator_type();  }
 
-   void destroy_alloc()
-   {  static_cast<allocator_type*>(m_nalloc_storage.address())->~allocator_type();  }
-
-   node_pointer &get_node_pointer()
+   node_pointer &get_node_pointer() BOOST_NOEXCEPT
    {  return m_ptr;  }
 
-   nallocator_type &node_alloc()
-   {  return *static_cast<nallocator_type*>(m_nalloc_storage.address()); }
-
-   const nallocator_type &node_alloc() const
-   {  return *static_cast<const nallocator_type*>(m_nalloc_storage.address()); }
-
-   node_pointer release()
-   {
-      node_pointer p(m_ptr);
-      m_ptr = node_pointer();
-      if(p)
-         this->destroy_alloc();
-      return p;
-   }
-
    ///@endcond
 
    public:
@@ -150,13 +151,13 @@ class node_handle
    //!
    //! <b>Postcondition</b>: this->empty()
    BOOST_CXX14_CONSTEXPR node_handle() BOOST_NOEXCEPT
-      :  m_ptr(), m_nalloc_storage()
-   {  BOOST_ASSERT(this->empty()); }
+      :  m_ptr()
+   { }
 
    //! <b>Effects</b>: Constructs a node_handle object initializing internal pointer with p.
-   //!   If p != nullptr copy constructs internal allocator al.
+   //!   If p != nullptr copy constructs internal allocator from al.
    node_handle(node_pointer p, const nallocator_type &al) BOOST_NOEXCEPT
-      :  m_ptr(p), m_nalloc_storage()
+      :  m_ptr(p)
    {
       if(m_ptr){
          ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(al);
@@ -172,12 +173,12 @@ class node_handle
    //! <b>Note</b>: Two node_handle's are related if only one of KeyMapped template parameter
    //!   of a node handle is void.
    template<class KeyMapped2>
-   node_handle( BOOST_RV_REF_BEG node_handle<NodeType, Value, Allocator, KeyMapped2> BOOST_RV_REF_END nh
+   node_handle( BOOST_RV_REF_BEG node_handle<NodeAllocator, KeyMapped2> BOOST_RV_REF_END nh
                , typename container_detail::enable_if_c
                   < ((unsigned)container_detail::is_same<KeyMapped,  void>::value +
                      (unsigned)container_detail::is_same<KeyMapped2, void>::value) == 1u
-                  >::type* = 0)
-      :  m_ptr(nh.get_node_pointer()), m_nalloc_storage()
+                  >::type* = 0) BOOST_NOEXCEPT
+      :  m_ptr(nh.get())
    {  this->move_construct_end(nh);  }
 
    //! <b>Effects</b>: Constructs a node_handle object initializing internal pointer with nh's internal pointer
@@ -186,43 +187,44 @@ class node_handle
    //!
    //! <b>Postcondition</b>: nh.empty()
    node_handle (BOOST_RV_REF(node_handle) nh) BOOST_NOEXCEPT
-      : m_ptr(nh.m_ptr), m_nalloc_storage()
+      : m_ptr(nh.m_ptr)
    {  this->move_construct_end(nh);  }
 
    //! <b>Effects</b>: If !this->empty(), destroys the value_type subobject in the container_node_type object
    //!   pointed to by c by calling allocator_traits<impl_defined>::destroy, then deallocates m_ptr by calling
-   //!   ator_traits::rebind_traits<container_node_type>::deallocate.
-   ~node_handle () BOOST_NOEXCEPT
+   //!   nator_traits::rebind_traits<container_node_type>::deallocate.
+   ~node_handle() BOOST_NOEXCEPT
    {
       if(!this->empty()){
-         this->destroy_node();
+         this->destroy_deallocate_node();
          this->destroy_alloc();
       }
    }
 
-   //! <b>Requires</b>: Either this->empty(), or ator_traits::propagate_on_container_move_assignment is true, or
+   //! <b>Requires</b>: Either this->empty(), or nator_traits::propagate_on_container_move_assignment is true, or
    //!   node_alloc() == nh.node_alloc().
    //!
    //! <b>Effects</b>: If m_ptr != nullptr, destroys the value_type subobject in the container_node_type object
-   //!   pointed to by m_ptr by calling ator_traits::destroy, then deallocates m_ptr by calling ator_-
-   //!   traits::rebind_traits<container_node_type>::deallocate. Assigns nh.m_ptr to m_ptr. If this->empty()
-   //!   or ator_traits::propagate_on_container_move_assignment is true, move assigns nh.node_alloc() to
+   //!   pointed to by m_ptr by calling nator_traits::destroy, then deallocates m_ptr by calling
+   //!   nator_traits::deallocate. Assigns nh.m_ptr to m_ptr. If this->empty()
+   //!   or nator_traits::propagate_on_container_move_assignment is true, move assigns nh.node_alloc() to
    //!   node_alloc(). Assigns nullptr to nh.m_ptr and assigns nullopt to nh.node_alloc().
+   //!
    //! <b>Returns</b>: *this.
    //!
    //! <b>Throws</b>: Nothing.
-   node_handle & operator=(BOOST_RV_REF(node_handle) nh)
+   node_handle & operator=(BOOST_RV_REF(node_handle) nh) BOOST_NOEXCEPT
    {
-      BOOST_ASSERT(this->empty() || nh.empty() || ator_traits::propagate_on_container_move_assignment::value 
-                   || ator_traits::equal(node_alloc(), nh.node_alloc()));
+      BOOST_ASSERT(this->empty() || nator_traits::propagate_on_container_move_assignment::value 
+                   || nator_traits::equal(node_alloc(), nh.node_alloc()));
 
       bool const was_this_non_null = !this->empty();
       bool const was_nh_non_null   = !nh.empty();
 
       if(was_nh_non_null){
          if(was_this_non_null){
-            this->destroy_node();
-            if(ator_traits::propagate_on_container_move_assignment::value){
+            this->destroy_deallocate_node();
+            if(nator_traits::propagate_on_container_move_assignment::value){
                this->node_alloc() = ::boost::move(nh.node_alloc());
             }
          }
@@ -234,7 +236,7 @@ class node_handle
          nh.destroy_alloc();
       }
       else if(was_this_non_null){
-         this->destroy_node();
+         this->destroy_deallocate_node();
          this->destroy_alloc();
          m_ptr = node_pointer();
       }
@@ -310,23 +312,23 @@ class node_handle
       return !this->m_ptr;
    }
 
-   //! <b>Requires</b>: this->empty(), or nh.empty(), or ator_traits::propagate_on_container_swap is true, or
+   //! <b>Requires</b>: this->empty(), or nh.empty(), or nator_traits::propagate_on_container_swap is true, or
    //!   node_alloc() == nh.node_alloc().
    //!
-   //! <b>Effects</b>: Calls swap(m_ptr, nh.m_ptr). If this->empty(), or nh.empty(), or ator_traits::propagate_on_-
+   //! <b>Effects</b>: Calls swap(m_ptr, nh.m_ptr). If this->empty(), or nh.empty(), or nator_traits::propagate_on_-
    //!   container_swap is true calls swap(node_alloc(), nh.node_alloc()).
    void swap(node_handle &nh)
-      BOOST_NOEXCEPT_IF(ator_traits::propagate_on_container_swap::value || ator_traits::is_always_equal::value)
+      BOOST_NOEXCEPT_IF(nator_traits::propagate_on_container_swap::value || nator_traits::is_always_equal::value)
    {
-      BOOST_ASSERT(this->empty() || nh.empty() || ator_traits::propagate_on_container_swap::value
-                   || ator_traits::equal(node_alloc(), nh.node_alloc()));
+      BOOST_ASSERT(this->empty() || nh.empty() || nator_traits::propagate_on_container_swap::value
+                   || nator_traits::equal(node_alloc(), nh.node_alloc()));
 
       bool const was_this_non_null = !this->empty();
       bool const was_nh_non_null   = !nh.empty();
 
       if(was_nh_non_null){
          if(was_this_non_null){
-            if(ator_traits::propagate_on_container_swap::value){
+            if(nator_traits::propagate_on_container_swap::value){
                ::boost::adl_move_swap(this->node_alloc(), nh.node_alloc());
             }
          }
@@ -337,11 +339,53 @@ class node_handle
       }
       else if(was_this_non_null){
          nh.move_construct_alloc(this->node_alloc());
-         nh.destroy_alloc();
+         this->destroy_alloc();
       }
       ::boost::adl_move_swap(m_ptr, nh.m_ptr);
    }
 
+   //! <b>Effects</b>: If this->empty() returns nullptr, otherwise returns m_ptr
+   //!   resets m_ptr to nullptr and destroys the internal allocator.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   node_pointer release() BOOST_NOEXCEPT
+   {
+      node_pointer p(m_ptr);
+      m_ptr = node_pointer();
+      if(p)
+         this->destroy_alloc();
+      return p;
+   }
+
+   //! <b>Effects</b>: Returns m_ptr.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   node_pointer get() const BOOST_NOEXCEPT
+   {
+      return m_ptr;
+   }
+
+   //! <b>Effects</b>: Returns a reference to the internal node allocator.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   nallocator_type &node_alloc() BOOST_NOEXCEPT
+   {
+      BOOST_ASSERT(!empty());
+      return *static_cast<nallocator_type*>(m_nalloc_storage.address());
+   }
+
+
+   //! <b>Effects</b>: Returns a reference to the internal node allocator.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   const nallocator_type &node_alloc() const BOOST_NOEXCEPT
+   {
+      BOOST_ASSERT(!empty());
+      return *static_cast<const nallocator_type*>(m_nalloc_storage.address());
+   }
+
    //! <b>Effects</b>: x.swap(y).
    //!
    friend void swap(node_handle & x, node_handle & y) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
diff --git a/boost/container/set.hpp b/boost/container/set.hpp
index 5cf0f96..8730b1c 100644
--- a/boost/container/set.hpp
+++ b/boost/container/set.hpp
@@ -112,48 +112,105 @@ class set
    //! <b>Effects</b>: Default constructs an empty set.
    //!
    //! <b>Complexity</b>: Constant.
-   set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                           container_detail::is_nothrow_default_constructible<Compare>::value)
+   
+   BOOST_CONTAINER_FORCEINLINE set()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified allocator object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit set(const allocator_type& a)
+      : base_t(a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit set(const Compare& comp)
+      : base_t(comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object
    //! and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit set(const Compare& comp,
-                const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified allocator object.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit set(const allocator_type& a)
-      : base_t(a)
-   {}
-
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty set using and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   set(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : base_t(true, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last)
+      : base_t(true, first, last)
    {}
 
    //! <b>Effects</b>: Constructs an empty set using the specified
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   set(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(true, first, last, key_compare(), a)
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(true, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp )
+      : base_t(ordered_range, first, last, comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -165,30 +222,76 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   set( ordered_unique_range_t, InputIterator first, InputIterator last
-      , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last
+      , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is il.begin() - il.end().
-   set(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il)
+      : base_t(true, il.begin(), il.end())
    {}
 
    //! <b>Effects</b>: Constructs an empty set using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is il.begin() - il.end().
-   set(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), Compare(), a)
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const Compare& comp )
+      : base_t(true, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -199,8 +302,7 @@ class set
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare()
-      , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
@@ -208,7 +310,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x)
+   BOOST_CONTAINER_FORCEINLINE set(const set& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
@@ -217,7 +319,7 @@ class set
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   set(BOOST_RV_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
@@ -225,7 +327,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE set(const set& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
@@ -233,14 +335,14 @@ class set
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   set(BOOST_RV_REF(set) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
    {  return static_cast<set&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! <b>Effects</b>: this->swap(x.get()).
@@ -251,7 +353,7 @@ class set
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   set& operator=(BOOST_RV_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -424,7 +526,7 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>:  Inserts an object of type Key constructed with
@@ -437,18 +539,18 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_SET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_unique(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_unique(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SET_EMPLACE_CODE)
@@ -513,7 +615,7 @@ class set
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_unique(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -521,16 +623,16 @@ class set
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end())
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_unique(il.begin(), il.end()); }
 #endif
 
    //! @copydoc ::boost::container::map::insert(node_type&&)
-   insert_return_type insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE insert_return_type insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_unique_node(boost::move(nh));  }
 
    //! @copydoc ::boost::container::map::insert(const_iterator, node_type&&)
-   insert_return_type insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE insert_return_type insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_unique_node(hint, boost::move(nh));  }
 
    //! @copydoc ::boost::container::map::merge(map<Key, T, C2, Allocator, Options>&)
@@ -586,6 +688,12 @@ class set
    //! <b>Complexity</b>: log(size())+N where N is the distance from first to last.
    iterator erase(const_iterator first, const_iterator last);
 
+   //! @copydoc ::boost::container::map::extract(const_iterator)
+   node_type extract(const_iterator p);
+
+   //! @copydoc ::boost::container::map::extract(const key_type&)
+   node_type extract(const key_type& x);
+
    //! <b>Effects</b>: Swaps the contents of *this and x.
    //!
    //! <b>Throws</b>: Nothing.
@@ -631,13 +739,13 @@ class set
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend());  }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x)
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::end());  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -671,13 +779,13 @@ class set
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
    {  return this->base_t::lower_bound_range(x);  }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
    {  return this->base_t::lower_bound_range(x);  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -737,11 +845,11 @@ class set
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
@@ -829,36 +937,79 @@ class multiset
    //////////////////////////////////////////////
 
    //! @copydoc ::boost::container::set::set()
-   multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE multiset()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
-   //! @copydoc ::boost::container::set::set(const Compare&, const allocator_type&)
-   explicit multiset(const Compare& comp,
-                     const allocator_type& a = allocator_type())
-      : base_t(comp, a)
-   {}
-
    //! @copydoc ::boost::container::set::set(const allocator_type&)
-   explicit multiset(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit multiset(const allocator_type& a)
       : base_t(a)
    {}
 
-   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   //! @copydoc ::boost::container::set::set(const Compare&)
+   BOOST_CONTAINER_FORCEINLINE explicit multiset(const Compare& comp)
+      : base_t(comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator)
    template <class InputIterator>
-   multiset(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last)
+      : base_t(false, first, last)
    {}
 
    //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const allocator_type&)
    template <class InputIterator>
-   multiset(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(false, first, last, key_compare(), a)
    {}
 
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(false, first, last, comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare&, const allocator_type&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multiset and
+   //! and inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last )
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -869,56 +1020,74 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   multiset( ordered_range_t, InputIterator first, InputIterator last
-           , const Compare& comp = Compare()
-           , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   multiset(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il)
+      : base_t(false, il.begin(), il.end())
    {}
 
    //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const allocator_type&)
-   multiset(std::initializer_list<value_type> il, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(false, il.begin(), il.end(), Compare(), a)
    {}
 
-   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   multiset(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare&)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare&)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
 
    //! @copydoc ::boost::container::set::set(const set &)
-   multiset(const multiset& x)
+   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
    //! @copydoc ::boost::container::set::set(set &&)
-   multiset(BOOST_RV_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
    //! @copydoc ::boost::container::set::set(const set &, const allocator_type &)
-   multiset(const multiset& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
    //! @copydoc ::boost::container::set::set(set &&, const allocator_type &)
-   multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! @copydoc ::boost::container::set::operator=(const set &)
-   multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
    {  return static_cast<multiset&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! @copydoc ::boost::container::set::operator=(set &&)
-   multiset& operator=(BOOST_RV_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -999,7 +1168,7 @@ class multiset
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   iterator emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_equal(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
@@ -1011,18 +1180,18 @@ class multiset
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_MULTISET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_equal(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_equal(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_MULTISET_EMPLACE_CODE)
@@ -1079,21 +1248,21 @@ class multiset
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_equal(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! @copydoc ::boost::container::set::insert(std::initializer_list<value_type>)
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_equal(il.begin(), il.end());  }
 #endif
 
    //! @copydoc ::boost::container::multimap::insert(node_type&&)
-   iterator insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_equal_node(boost::move(nh));  }
 
    //! @copydoc ::boost::container::multimap::insert(const_iterator, node_type&&)
-   iterator insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_equal_node(hint, boost::move(nh));  }
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
@@ -1135,6 +1304,12 @@ class multiset
    //! @copydoc ::boost::container::set::erase(const_iterator,const_iterator)
    iterator erase(const_iterator first, const_iterator last);
 
+   //! @copydoc ::boost::container::multimap::extract(const_iterator)
+   node_type extract(const_iterator p);
+
+   //! @copydoc ::boost::container::multimap::extract(const key_type&)
+   node_type extract(const key_type& x);
+
    //! @copydoc ::boost::container::set::swap
    void swap(multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
@@ -1219,11 +1394,11 @@ class multiset
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(p, ::boost::forward<KeyType>(x)); }
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
diff --git a/boost/container/small_vector.hpp b/boost/container/small_vector.hpp
index 1444624..804740c 100644
--- a/boost/container/small_vector.hpp
+++ b/boost/container/small_vector.hpp
@@ -387,8 +387,8 @@ class small_vector_base
          this->steal_resources(x);
       }
       else{
-         this->assign( boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.end  ()))
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end  ()))
                      );
       }
    }
diff --git a/boost/container/static_vector.hpp b/boost/container/static_vector.hpp
index 21168cb..4a341c3 100644
--- a/boost/container/static_vector.hpp
+++ b/boost/container/static_vector.hpp
@@ -113,6 +113,8 @@ class static_vector
    template<class U, std::size_t OtherCapacity>
    friend class static_vector;
 
+   public:
+   typedef container_detail::static_storage_allocator<Value, Capacity> allocator_type;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 public:
@@ -252,6 +254,19 @@ public:
         : base_t(other)
     {}
 
+    BOOST_CONTAINER_FORCEINLINE static_vector(static_vector const& other, const allocator_type &)
+       : base_t(other)
+    {}
+
+    BOOST_CONTAINER_FORCEINLINE static_vector(BOOST_RV_REF(static_vector) other,  const allocator_type &)
+       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<value_type>::value)
+       : base_t(BOOST_MOVE_BASE(base_t, other))
+    {}
+
+    BOOST_CONTAINER_FORCEINLINE explicit static_vector(const allocator_type &)
+       : base_t()
+    {}
+
     //! @pre <tt>other.size() <= capacity()</tt>.
     //!
     //! @brief Constructs a copy of other static_vector.
diff --git a/boost/container/throw_exception.hpp b/boost/container/throw_exception.hpp
index 118cc39..1b6eec1 100644
--- a/boost/container/throw_exception.hpp
+++ b/boost/container/throw_exception.hpp
@@ -51,31 +51,41 @@ namespace container {
 
    inline void throw_bad_alloc()
    {
-      BOOST_ASSERT(!"boost::container bad_alloc thrown");
+      const char msg[] = "boost::container bad_alloc thrown";
+      (void)msg;
+      BOOST_ASSERT(!msg);
       std::abort();
    }
 
    inline void throw_out_of_range(const char* str)
    {
-      BOOST_ASSERT_MSG(!"boost::container out_of_range thrown", str);
+      const char msg[] = "boost::container out_of_range thrown";
+      (void)msg; (void)str;
+      BOOST_ASSERT_MSG(!msg, str);
       std::abort();
    }
 
    inline void throw_length_error(const char* str)
    {
-      BOOST_ASSERT_MSG(!"boost::container length_error thrown", str);
+      const char msg[] = "boost::container length_error thrown";
+      (void)msg; (void)str;
+      BOOST_ASSERT_MSG(!msg, str);
       std::abort();
    }
 
    inline void throw_logic_error(const char* str)
    {
-      BOOST_ASSERT_MSG(!"boost::container logic_error thrown", str);
+      const char msg[] = "boost::container logic_error thrown";
+      (void)msg; (void)str;
+      BOOST_ASSERT_MSG(!msg, str);
       std::abort();
    }
 
    inline void throw_runtime_error(const char* str)
    {
-      BOOST_ASSERT_MSG(!"boost::container runtime_error thrown", str);
+      const char msg[] = "boost::container runtime_error thrown";
+      (void)msg; (void)str;
+      BOOST_ASSERT_MSG(!msg, str);
       std::abort();
    }
 
diff --git a/boost/container/vector.hpp b/boost/container/vector.hpp
index 336d616..8e1e7a5 100644
--- a/boost/container/vector.hpp
+++ b/boost/container/vector.hpp
@@ -36,10 +36,10 @@
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/next_capacity.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/version_type.hpp>
 // intrusive
@@ -54,6 +54,10 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
+// move/algo
+#include <boost/move/algo/adaptive_merge.hpp>
+#include <boost/move/algo/unique.hpp>
+#include <boost/move/algo/predicate.hpp>
 // other
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/assert.hpp>
@@ -69,12 +73,8 @@ namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-//#define BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 namespace container_detail {
 
-#ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 template <class Pointer, bool IsConst>
 class vec_iterator
 {
@@ -256,45 +256,6 @@ BOOST_CONTAINER_FORCEINLINE Pointer &get_ptr(container_detail::vec_iterator<Poin
 
 namespace container_detail {
 
-#else //ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
-template< class MaybeConstPointer
-        , bool ElementTypeIsConst
-            = is_const< typename boost::intrusive::pointer_traits<MaybeConstPointer>::element_type>::value >
-struct vector_get_ptr_pointer_to_non_const
-{
-   typedef MaybeConstPointer                                         const_pointer;
-   typedef boost::intrusive::pointer_traits<const_pointer>           pointer_traits_t;
-   typedef typename pointer_traits_t::element_type                   element_type;
-   typedef typename remove_const<element_type>::type                 non_const_element_type;
-   typedef typename pointer_traits_t
-      ::template rebind_pointer<non_const_element_type>::type        return_type;
-
-   BOOST_CONTAINER_FORCEINLINE static return_type get_ptr(const const_pointer &ptr) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return boost::intrusive::pointer_traits<return_type>::const_cast_from(ptr);  }
-};
-
-template<class Pointer>
-struct vector_get_ptr_pointer_to_non_const<Pointer, false>
-{
-   typedef const Pointer & return_type;
-   BOOST_CONTAINER_FORCEINLINE static return_type get_ptr(const Pointer &ptr) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return ptr;  }
-};
-
-}  //namespace container_detail {
-
-template<class MaybeConstPointer>
-BOOST_CONTAINER_FORCEINLINE typename container_detail::vector_get_ptr_pointer_to_non_const<MaybeConstPointer>::return_type
-   vector_iterator_get_ptr(const MaybeConstPointer &ptr) BOOST_NOEXCEPT_OR_NOTHROW
-{
-   return container_detail::vector_get_ptr_pointer_to_non_const<MaybeConstPointer>::get_ptr(ptr);
-}
-
-namespace container_detail {
-
-#endif   //#ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-
 struct uninitialized_size_t {};
 static const uninitialized_size_t uninitialized_size = uninitialized_size_t();
 
@@ -418,7 +379,7 @@ struct vector_alloc_holder
       allocator_type &x_alloc = holder.alloc();
       if(this->is_propagable_from(x_alloc, holder.start(), this_alloc, true)){
          if(this->m_capacity){
-            this->alloc().deallocate(this->m_start, this->m_capacity);
+            allocator_traits_type::deallocate(this->alloc(), this->m_start, this->m_capacity);
          }
          m_start = holder.m_start;
          m_capacity = holder.m_capacity;
@@ -454,7 +415,7 @@ struct vector_alloc_holder
    BOOST_CONTAINER_FORCEINLINE ~vector_alloc_holder() BOOST_NOEXCEPT_OR_NOTHROW
    {
       if(this->m_capacity){
-         this->alloc().deallocate(this->m_start, this->m_capacity);
+         allocator_traits_type::deallocate(this->alloc(), this->m_start, this->m_capacity);
       }
    }
 
@@ -609,7 +570,7 @@ struct vector_alloc_holder<Allocator, version_0>
       , m_size(holder.m_size) //Size is initialized here so vector should only call uninitialized_xxx after this
    {
       ::boost::container::uninitialized_move_alloc_n
-         (this->alloc(), container_detail::to_raw_pointer(holder.start()), m_size, container_detail::to_raw_pointer(this->start()));
+         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), m_size, boost::movelib::to_raw_pointer(this->start()));
    }
 
    template<class OtherAllocator, class OtherAllocatorVersion>
@@ -621,7 +582,7 @@ struct vector_alloc_holder<Allocator, version_0>
       const size_type n = holder.m_size;
       this->priv_first_allocation(n);
       ::boost::container::uninitialized_move_alloc_n
-         (this->alloc(), container_detail::to_raw_pointer(holder.start()), n, container_detail::to_raw_pointer(this->start()));
+         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), n, boost::movelib::to_raw_pointer(this->start()));
    }
 
    BOOST_CONTAINER_FORCEINLINE void priv_first_allocation(size_type cap)
@@ -675,8 +636,8 @@ struct vector_alloc_holder<Allocator, version_0>
    void priv_deep_swap(vector_alloc_holder<OtherAllocator, OtherAllocatorVersion> &x)
    {
       const size_type MaxTmpStorage = sizeof(value_type)*Allocator::internal_capacity;
-      value_type *const first_this = container_detail::to_raw_pointer(this->start());
-      value_type *const first_x = container_detail::to_raw_pointer(x.start());
+      value_type *const first_this = boost::movelib::to_raw_pointer(this->start());
+      value_type *const first_x = boost::movelib::to_raw_pointer(x.start());
 
       if(this->m_size < x.m_size){
          boost::container::deep_swap_alloc_n<MaxTmpStorage>(this->alloc(), first_this, this->m_size, first_x, x.m_size);
@@ -747,13 +708,8 @@ class vector
    typedef typename ::boost::container::allocator_traits<Allocator>::difference_type   difference_type;
    typedef Allocator                                                                   allocator_type;
    typedef Allocator                                                                   stored_allocator_type;
-   #if defined BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
-   typedef BOOST_CONTAINER_IMPDEF(pointer)                                             iterator;
-   typedef BOOST_CONTAINER_IMPDEF(const_pointer)                                       const_iterator;
-   #else
    typedef BOOST_CONTAINER_IMPDEF(iterator_impl)                                       iterator;
    typedef BOOST_CONTAINER_IMPDEF(const_iterator_impl)                                 const_iterator;
-   #endif
    typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<iterator>)        reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(boost::container::reverse_iterator<const_iterator>)  const_reverse_iterator;
 
@@ -1186,7 +1142,7 @@ class vector
       if (first == last){
          //There are no more elements in the sequence, erase remaining
          T* const end_pos = this->priv_raw_end();
-         const size_type n = static_cast<size_type>(end_pos - container_detail::iterator_to_raw_pointer(cur));
+         const size_type n = static_cast<size_type>(end_pos - boost::movelib::iterator_to_raw_pointer(cur));
          this->priv_destroy_last_n(n);
       }
       else{
@@ -1238,7 +1194,7 @@ class vector
             pointer const old_p = this->m_holder.start();
             if(old_p){
                this->priv_destroy_all();
-               this->m_holder.alloc().deallocate(old_p, old_capacity);
+               allocator_traits_type::deallocate(this->m_holder.alloc(), old_p, old_capacity);
             }
             this->m_holder.start(ret);
             this->m_holder.capacity(real_cap);
@@ -2005,7 +1961,7 @@ class vector
    {
       BOOST_ASSERT(this->priv_in_range(position));
       const pointer p = vector_iterator_get_ptr(position);
-      T *const pos_ptr = container_detail::to_raw_pointer(p);
+      T *const pos_ptr = boost::movelib::to_raw_pointer(p);
       T *const beg_ptr = this->priv_raw_begin();
       T *const new_end_ptr = ::boost::container::move(pos_ptr + 1, beg_ptr + this->m_holder.m_size, pos_ptr);
       //Move elements forward and destroy last
@@ -2025,9 +1981,9 @@ class vector
          (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last)));
       if (first != last){
          T* const old_end_ptr = this->priv_raw_end();
-         T* const first_ptr = container_detail::to_raw_pointer(vector_iterator_get_ptr(first));
-         T* const last_ptr  = container_detail::to_raw_pointer(vector_iterator_get_ptr(last));
-         T* const ptr = container_detail::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
+         T* const first_ptr = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(first));
+         T* const last_ptr  = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(last));
+         T* const ptr = boost::movelib::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
          this->priv_destroy_last_n(old_end_ptr - ptr);
       }
       return iterator(vector_iterator_get_ptr(first));
@@ -2231,46 +2187,19 @@ class vector
       if(BOOST_LIKELY(s)){
          size_type const c = this->capacity();
          size_type const free_c = (c - s);
-         //Use a new buffer if current one is too small for new elements,
-         //or there is no room for position indexes
+         //Use a new buffer if current one is too small for new elements
          if(free_c < n){
-            size_type const new_size = s + n;
-            size_type new_cap = new_size;
-            pointer p = pointer();
-            p = this->m_holder.allocation_command(allocate_new, new_size, new_cap, p);
-            this->priv_merge_in_new_buffer(UniqueBool(), first, n, comp, p, new_cap);
+            this->priv_merge_in_new_buffer(UniqueBool(), first, n, comp, alloc_version());
          }
-         else if(!UniqueBool::value && free_c >= n){
-            typedef container_detail::vector_merge_cursor<T, size_type, BidirIt, Compare> inserter_t;
-            T* const pbeg = this->priv_raw_begin();
-            return this->priv_insert_ordered_at(n, inserter_t(pbeg, pbeg + s, last, comp));
-         }
-         else{ //UniqueBool::value == true and free_c >= n
-            std::size_t remaining = n;
-            static const std::size_t PosCount = 64u;
-            size_type positions[PosCount];
-            size_type *indexes = 0;
-            while(remaining){
-               //Query for room to store indexes in the remaining buffer
-               boost::uintptr_t const szt_align_mask = container_detail::alignment_of<size_type>::value - 1;
-               boost::uintptr_t const addr = boost::uintptr_t(this->priv_raw_begin() + s + n);
-               boost::uintptr_t const capaddr = boost::uintptr_t(this->priv_raw_begin() + c);
-               boost::uintptr_t const aligned_addr = (addr + szt_align_mask) & ~szt_align_mask;
-               indexes =  reinterpret_cast<size_type *>(aligned_addr);
-               std::size_t index_capacity = (aligned_addr >= capaddr) ? 0u : (capaddr - aligned_addr)/sizeof(size_type);
-
-               //Capacity is constant, we're not going to change it
-               if(index_capacity < PosCount){
-                  indexes =  positions; 
-                  index_capacity = PosCount;
-               }
-               if(index_capacity > remaining)
-                  index_capacity = remaining;
-               BidirIt limit = first;
-               boost::container::iterator_advance(limit, index_capacity);
-               this->priv_insert_ordered_range(UniqueBool(), index_capacity, first, limit, indexes, comp);
-               first = limit;
-               remaining -= index_capacity;
+         else{
+            T *raw_pos = boost::movelib::iterator_to_raw_pointer(this->insert(this->cend(), first, last));
+            T *raw_beg = this->priv_raw_begin();
+            T *raw_end = this->priv_raw_end();
+            boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, free_c - n);
+            if(UniqueBool::value){
+               size_type const count =
+                  static_cast<size_type>(raw_end - boost::movelib::unique(raw_beg, raw_end, boost::movelib::negate<Compare>(comp)));
+               this->priv_destroy_last_n(count);
             }
          }
       }
@@ -2279,57 +2208,20 @@ class vector
       }
    }
 
-   template <class UniqueBool, class BidirIt, class Compare>
-   void priv_insert_ordered_range
-      (UniqueBool, size_type const n, BidirIt first, BidirIt const last, size_type positions[], Compare comp)
+   template<class UniqueBool, class FwdIt, class Compare>
+   void priv_merge_in_new_buffer(UniqueBool, FwdIt, size_type, Compare, version_0)
    {
-      //Linear: at most N + M -1 comparisons
-      //Log: MlogN
-      //Average
-      //Linear: N + M - 2
-      //Log: MlogN
-      //N+M - 2
-      //N
-      //(N+M)/2 < MlogN
-      //(N/M+1)/2 <= logN
-      //bool const linear = !s || !n || (s <= n) || ((s+n)/n/2 < logN);
-      size_type const s = this->size();
-      size_type remaining = n;
-      T* const pbeg = this->priv_raw_begin();
-      T* const pend = pbeg + s;
-      T* pcur = pbeg;
-      size_type *position = positions;
-      size_type added_in_middle = 0;
-      if(first != last && pcur != pend){
-         while(1){
-            //maintain stability moving external values only if they are strictly less
-            if(comp(*first, *pcur)) { 
-               *position = static_cast<size_type>(pcur - pbeg);
-               BOOST_ASSERT((position == positions) || (*(position-1) == size_type(-1)) || (*(position-1) <= *position));
-               ++position;
-               ++added_in_middle;
-               --remaining;
-               if(++first == last)  break;
-            }
-            else if(UniqueBool::value && !comp(*pcur, *first)){
-               *position = size_type(-1);
-               ++position;
-               --remaining;
-               if(++first == last)  break;
-            }
-            else{
-               if(++pcur == pend)   break;
-            }
-         }
-      }
-      this->insert_ordered_at(added_in_middle, position, first);
-      this->insert(this->cend(), remaining, first, last);
+      throw_bad_alloc();
    }
 
-   template<class UniqueBool, class FwdIt, class Compare>
-   void priv_merge_in_new_buffer
-      (UniqueBool, FwdIt first, size_type n, Compare comp, pointer new_storage, size_type const new_cap)
+   template<class UniqueBool, class FwdIt, class Compare, class Version>
+   void priv_merge_in_new_buffer(UniqueBool, FwdIt first, size_type n, Compare comp, Version)
    {
+      size_type const new_size = this->size() + n;
+      size_type new_cap = new_size;
+      pointer p = pointer();
+      pointer const new_storage = this->m_holder.allocation_command(allocate_new, new_size, new_cap, p);
+
       BOOST_ASSERT((new_cap >= this->size() ) && (new_cap - this->size()) >= n);
       allocator_type &a = this->m_holder.alloc();
       typename value_traits::ArrayDeallocator new_buffer_deallocator(new_storage, a, new_cap);
@@ -2337,7 +2229,7 @@ class vector
       T* pbeg  = this->priv_raw_begin();
       size_type const old_size = this->size();
       T* const pend = pbeg + old_size;
-      T* d_first = container_detail::to_raw_pointer(new_storage);
+      T* d_first = boost::movelib::to_raw_pointer(new_storage);
       size_type added = n;
       //Merge in new buffer loop
       while(1){
@@ -2351,7 +2243,7 @@ class vector
          }
          //maintain stability moving external values only if they are strictly less
          else if(comp(*first, *pbeg)) {
-            allocator_traits_type::construct( this->m_holder.alloc(), d_first, ::boost::move(*first) );
+            allocator_traits_type::construct( this->m_holder.alloc(), d_first, *first );
             new_values_destroyer.increment_size(1u);
             ++first;
             --n;
@@ -2363,7 +2255,7 @@ class vector
             --added;
          }
          else{
-            allocator_traits_type::construct( this->m_holder.alloc(), d_first, ::boost::move(*pbeg) );
+            allocator_traits_type::construct( this->m_holder.alloc(), d_first, boost::move(*pbeg) );
             new_values_destroyer.increment_size(1u);
             ++pbeg;
             ++d_first;
@@ -2373,8 +2265,8 @@ class vector
       //Nothrow operations
       pointer const old_p     = this->m_holder.start();
       size_type const old_cap = this->m_holder.capacity();
-      boost::container::destroy_alloc_n(a, container_detail::to_raw_pointer(old_p), old_size);
-      a.deallocate(old_p, old_cap);
+      boost::container::destroy_alloc_n(a, boost::movelib::to_raw_pointer(old_p), old_size);
+      allocator_traits_type::deallocate(a, old_p, old_cap);
       this->m_holder.m_size = old_size + added;
       this->m_holder.start(new_storage);
       this->m_holder.capacity(new_cap);
@@ -2439,13 +2331,13 @@ class vector
       }
       else if(is_propagable_from_x){
          this->clear();
-         this->m_holder.alloc().deallocate(this->m_holder.m_start, this->m_holder.m_capacity);
+         allocator_traits_type::deallocate(this->m_holder.alloc(), this->m_holder.m_start, this->m_holder.m_capacity);
          this->m_holder.steal_resources(x.m_holder);
       }
       //Else do a one by one move
       else{
-         this->assign( boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.end()  ))
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end()  ))
                      );
       }
       //Move allocator if needed
@@ -2514,8 +2406,8 @@ class vector
          }
          //... and move-insert the remaining range
          sml.insert( sml.cend()
-                   , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(big.nth(common_elements)))
-                   , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(big.end()))
+                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
+                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
                    );
          //Destroy remaining elements
          big.erase(big.nth(common_elements), big.cend());
@@ -2540,7 +2432,7 @@ class vector
       pointer const p = allocator_traits_type::allocate(this->m_holder.alloc(), new_cap, this->m_holder.m_start);
       //We will reuse insert code, so create a dummy input iterator
       this->priv_forward_range_insert_new_allocation
-         ( container_detail::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
+         ( boost::movelib::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
    }
 
    void priv_reserve_no_capacity(size_type new_cap, version_2)
@@ -2561,7 +2453,7 @@ class vector
          this->m_holder.capacity(real_cap);
       }
       else{ //If there is no forward expansion, move objects, we will reuse insertion code
-         T * const new_mem = container_detail::to_raw_pointer(ret);
+         T * const new_mem = boost::movelib::to_raw_pointer(ret);
          T * const ins_pos = this->priv_raw_end();
          if(reuse){   //Backwards (and possibly forward) expansion
             #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -2677,7 +2569,7 @@ class vector
       if(cp){
          const size_type sz = this->size();
          if(!sz){
-            this->m_holder.alloc().deallocate(this->m_holder.m_start, cp);
+            allocator_traits_type::deallocate(this->m_holder.alloc(), this->m_holder.m_start, cp);
             this->m_holder.m_start     = pointer();
             this->m_holder.m_capacity  = 0;
          }
@@ -2691,7 +2583,7 @@ class vector
             ++this->num_alloc;
             #endif
             this->priv_forward_range_insert_new_allocation
-               ( container_detail::to_raw_pointer(p), sz
+               ( boost::movelib::to_raw_pointer(p), sz
                , this->priv_raw_begin(), 0, this->priv_dummy_empty_proxy());
          }
       }
@@ -2703,7 +2595,7 @@ class vector
       if(cp){
          const size_type sz = this->size();
          if(!sz){
-            this->m_holder.alloc().deallocate(this->m_holder.m_start, cp);
+            allocator_traits_type::deallocate(this->m_holder.alloc(), this->m_holder.m_start, cp);
             this->m_holder.m_start     = pointer();
             this->m_holder.m_capacity  = 0;
          }
@@ -2735,11 +2627,11 @@ class vector
    {
       //Check if we have enough memory or try to expand current memory
       const size_type n_pos = pos - this->m_holder.start();
-      T *const raw_pos = container_detail::to_raw_pointer(pos);
+      T *const raw_pos = boost::movelib::to_raw_pointer(pos);
 
       const size_type new_cap = this->m_holder.next_capacity(n);
       //Pass the hint so that allocators can take advantage of this.
-      T * const new_buf = container_detail::to_raw_pointer
+      T * const new_buf = boost::movelib::to_raw_pointer
          (allocator_traits_type::allocate(this->m_holder.alloc(), new_cap, this->m_holder.m_start));
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       ++this->num_alloc;
@@ -2754,7 +2646,7 @@ class vector
       (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
    {
       //Check if we have enough memory or try to expand current memory
-      T *const raw_pos = container_detail::to_raw_pointer(pos);
+      T *const raw_pos = boost::movelib::to_raw_pointer(pos);
       const size_type n_pos = raw_pos - this->priv_raw_begin();
 
       //There is not enough memory, allocate a new
@@ -2781,7 +2673,7 @@ class vector
             ++this->num_expand_bwd;
             #endif
             this->priv_forward_range_insert_expand_backwards
-               (container_detail::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
+               (boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
          }
       }
       //New buffer
@@ -2790,7 +2682,7 @@ class vector
          ++this->num_alloc;
          #endif
          this->priv_forward_range_insert_new_allocation
-            ( container_detail::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
+            ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
       }
 
       return iterator(this->m_holder.start() + n_pos);
@@ -2810,7 +2702,7 @@ class vector
       }
       else{
          //Expand forward
-         T *const raw_pos = container_detail::to_raw_pointer(pos);
+         T *const raw_pos = boost::movelib::to_raw_pointer(pos);
          const size_type n_pos = raw_pos - this->priv_raw_begin();
          this->priv_forward_range_insert_expand_forward(raw_pos, n, insert_range_proxy);
          return iterator(this->m_holder.start() + n_pos);
@@ -2926,10 +2818,10 @@ class vector
    }
 
    private:
-   T *priv_raw_begin() const
-   {  return container_detail::to_raw_pointer(m_holder.start());  }
+   BOOST_CONTAINER_FORCEINLINE T *priv_raw_begin() const
+   {  return boost::movelib::to_raw_pointer(m_holder.start());  }
 
-   T* priv_raw_end() const
+   BOOST_CONTAINER_FORCEINLINE T* priv_raw_end() const
    {  return this->priv_raw_begin() + this->m_holder.m_size;  }
 
    template <class InsertionProxy>
@@ -3017,7 +2909,7 @@ class vector
          //If there is allocated memory, destroy and deallocate
          if(!value_traits::trivial_dctr_after_move)
             boost::container::destroy_alloc_n(this->get_stored_allocator(), old_buffer, this->m_holder.m_size);
-         this->m_holder.alloc().deallocate(this->m_holder.start(), this->m_holder.capacity());
+         allocator_traits_type::deallocate(this->m_holder.alloc(), this->m_holder.start(), this->m_holder.capacity());
       }
       this->m_holder.start(new_start);
       this->m_holder.m_size = new_finish - new_start;
diff --git a/boost/core/addressof.hpp b/boost/core/addressof.hpp
index 0a2b46b..8ddda8b 100644
--- a/boost/core/addressof.hpp
+++ b/boost/core/addressof.hpp
@@ -42,7 +42,7 @@ addressof(T& o) BOOST_NOEXCEPT
 
 } /* boost */
 #else
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <cstddef>
 
 namespace boost {
@@ -117,7 +117,6 @@ struct address_of<const volatile addressof_null_t> {
 } /* detail */
 
 #if defined(BOOST_NO_CXX11_SFINAE_EXPR) || \
-    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
     defined(BOOST_NO_CXX11_CONSTEXPR) || \
     defined(BOOST_NO_CXX11_DECLTYPE)
 #define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF
@@ -171,7 +170,7 @@ const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]
 namespace detail {
 
 template<class T>
-T&& addressof_declval() BOOST_NOEXCEPT;
+T addressof_declval() BOOST_NOEXCEPT;
 
 template<class>
 struct addressof_void {
@@ -262,4 +261,14 @@ addressof(T& o) BOOST_NOEXCEPT
 } /* boost */
 #endif
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+namespace boost {
+
+template<class T>
+const T* addressof(const T&&) = delete;
+
+} /* boost */
+#endif
+
 #endif
diff --git a/boost/core/no_exceptions_support.hpp b/boost/core/no_exceptions_support.hpp
index a697f01..e2453d0 100644
--- a/boost/core/no_exceptions_support.hpp
+++ b/boost/core/no_exceptions_support.hpp
@@ -21,7 +21,7 @@
 //----------------------------------------------------------------------
 
 #include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 #if !(defined BOOST_NO_EXCEPTIONS)
 #    define BOOST_TRY { try
diff --git a/boost/core/ref.hpp b/boost/core/ref.hpp
index 47dc858..7d768ff 100644
--- a/boost/core/ref.hpp
+++ b/boost/core/ref.hpp
@@ -8,8 +8,8 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/core/addressof.hpp>
 
 //
 //  ref.hpp - ref/cref, useful helper functions
diff --git a/boost/cstdint.hpp b/boost/cstdint.hpp
index bf7097e..5e1411a 100644
--- a/boost/cstdint.hpp
+++ b/boost/cstdint.hpp
@@ -367,14 +367,11 @@ namespace boost
 #include <stddef.h>
 #endif
 
-// PGI seems to not support intptr_t/uintptr_t properly. BOOST_HAS_STDINT_H is not defined for this compiler by Boost.Config.
-#if !defined(__PGIC__)
-
 #if (defined(BOOST_WINDOWS) && !defined(_WIN32_WCE)) \
     || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
-    || defined(__CYGWIN__) \
+    || defined(__CYGWIN__) || defined(__VXWORKS__) \
     || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
-    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun)
+    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || (defined(sun) && !defined(BOOST_HAS_STDINT_H)) || defined(INTPTR_MAX)
 
 namespace boost {
     using ::intptr_t;
@@ -393,8 +390,6 @@ namespace boost {
 
 #endif
 
-#endif // !defined(__PGIC__)
-
 #endif // BOOST_CSTDINT_HPP
 
 
@@ -422,6 +417,20 @@ INT#_C macros if they're not already defined (John Maddock).
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
+//
+// Undef the macros as a precaution, since we may get here if <stdint.h> has failed
+// to define them all, see https://svn.boost.org/trac/boost/ticket/12786
+//
+#undef INT8_C
+#undef INT16_C
+#undef INT32_C
+#undef INT64_C
+#undef INTMAX_C
+#undef UINT8_C
+#undef UINT16_C
+#undef UINT32_C
+#undef UINT64_C
+#undef UINTMAX_C
 
 #include <limits.h>
 # define BOOST__STDC_CONSTANT_MACROS_DEFINED
diff --git a/boost/detail/container_fwd.hpp b/boost/detail/container_fwd.hpp
new file mode 100644
index 0000000..04ce972
--- /dev/null
+++ b/boost/detail/container_fwd.hpp
@@ -0,0 +1,157 @@
+
+// Copyright 2005-2011 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Note: if you change this include guard, you also need to change
+// container_fwd_compile_fail.cpp
+#if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP)
+#define BOOST_DETAIL_CONTAINER_FWD_HPP
+
+#if defined(_MSC_VER) && \
+    !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+////////////////////////////////////////////////////////////////////////////////
+//                                                                            //
+// Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to      //
+// forward declare standard containers.                                       //
+//                                                                            //
+// BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it //
+// normally doesn't.                                                          //
+//                                                                            //
+// BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD.        //
+//                                                                            //
+////////////////////////////////////////////////////////////////////////////////
+
+#if !defined(BOOST_DETAIL_NO_CONTAINER_FWD)
+#  if defined(BOOST_DETAIL_CONTAINER_FWD)
+     // Force forward declarations.
+#  elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+     // STLport
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__LIBCOMO__)
+     // Comeau STL:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+     // Rogue Wave library:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(_LIBCPP_VERSION)
+     // libc++
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+     // GNU libstdc++ 3
+     //
+     // Disable forwarding for all recent versions, as the library has a
+     // versioned namespace mode, and I don't know how to detect it.
+#    if __GLIBCXX__ >= 20070513 \
+        || defined(_GLIBCXX_DEBUG) \
+        || defined(_GLIBCXX_PARALLEL) \
+        || defined(_GLIBCXX_PROFILE)
+#      define BOOST_DETAIL_NO_CONTAINER_FWD
+#    else
+#      if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530
+#        define BOOST_CONTAINER_FWD_COMPLEX_STRUCT
+#      endif
+#    endif
+#  elif defined(__STL_CONFIG_H)
+     // generic SGI STL
+     //
+     // Forward declaration seems to be okay, but it has a couple of odd
+     // implementations.
+#    define BOOST_CONTAINER_FWD_BAD_BITSET
+#    if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG)
+#      define BOOST_CONTAINER_FWD_BAD_DEQUE
+#     endif
+#  elif defined(__MSL_CPP__)
+     // MSL standard lib:
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif defined(__IBMCPP__)
+     // The default VACPP std lib, forward declaration seems to be fine.
+#  elif defined(MSIPL_COMPILE_H)
+     // Modena C++ standard library
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+     // Dinkumware Library (this has to appear after any possible replacement
+     // libraries)
+#  else
+#    define BOOST_DETAIL_NO_CONTAINER_FWD
+#  endif
+#endif
+
+#if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY)
+
+#if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \
+    !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+
+#include <deque>
+#include <list>
+#include <vector>
+#include <map>
+#include <set>
+#include <bitset>
+#include <string>
+#include <complex>
+
+#else
+
+#include <cstddef>
+
+#if defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+#include <deque>
+#endif
+
+#if defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+#include <bitset>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4099) // struct/class mismatch in fwd declarations
+#endif
+
+namespace std
+{
+    template <class T> class allocator;
+    template <class charT, class traits, class Allocator> class basic_string;
+
+    template <class charT> struct char_traits;
+
+#if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT)
+    template <class T> struct complex;
+#else
+    template <class T> class complex;
+#endif
+
+#if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE)
+    template <class T, class Allocator> class deque;
+#endif
+
+    template <class T, class Allocator> class list;
+    template <class T, class Allocator> class vector;
+    template <class Key, class T, class Compare, class Allocator> class map;
+    template <class Key, class T, class Compare, class Allocator>
+    class multimap;
+    template <class Key, class Compare, class Allocator> class set;
+    template <class Key, class Compare, class Allocator> class multiset;
+
+#if !defined(BOOST_CONTAINER_FWD_BAD_BITSET)
+    template <size_t N> class bitset;
+#endif
+    template <class T1, class T2> struct pair;
+}
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_DETAIL_NO_CONTAINER_FWD &&
+       // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD)
+
+#endif // BOOST_DETAIL_TEST_CONFIG_ONLY
+
+#endif
diff --git a/boost/detail/workaround.hpp b/boost/detail/workaround.hpp
index 7727aaf..fb96115 100644
--- a/boost/detail/workaround.hpp
+++ b/boost/detail/workaround.hpp
@@ -3,270 +3,8 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 #ifndef WORKAROUND_DWA2002126_HPP
-# define WORKAROUND_DWA2002126_HPP
+#define WORKAROUND_DWA2002126_HPP
 
-// Compiler/library version workaround macro
-//
-// Usage:
-//
-//     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-//        // workaround for eVC4 and VC6
-//        ... // workaround code here
-//     #endif
-//
-// When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
-// first argument must be undefined or expand to a numeric
-// value. The above expands to:
-//
-//     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
-//
-// When used for workarounds that apply to the latest known version 
-// and all earlier versions of a compiler, the following convention 
-// should be observed:
-//
-//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
-//
-// The version number in this case corresponds to the last version in
-// which the workaround was known to have been required. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro
-// BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates
-// the workaround for any version of the compiler. When
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or
-// error will be issued if the compiler version exceeds the argument
-// to BOOST_TESTED_AT().  This can be used to locate workarounds which
-// may be obsoleted by newer versions.
-
-# ifndef BOOST_STRICT_CONFIG
-
-#include <boost/config.hpp>
-
-#ifndef __BORLANDC__
-#define __BORLANDC___WORKAROUND_GUARD 1
-#else
-#define __BORLANDC___WORKAROUND_GUARD 0
-#endif
-#ifndef __CODEGEARC__
-#define __CODEGEARC___WORKAROUND_GUARD 1
-#else
-#define __CODEGEARC___WORKAROUND_GUARD 0
-#endif
-#ifndef _MSC_VER
-#define _MSC_VER_WORKAROUND_GUARD 1
-#else
-#define _MSC_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef _MSC_FULL_VER
-#define _MSC_FULL_VER_WORKAROUND_GUARD 1
-#else
-#define _MSC_FULL_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_MSVC
-#define BOOST_MSVC_WORKAROUND_GUARD 1
-#else
-#define BOOST_MSVC_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_MSVC_FULL_VER
-#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
-#else
-#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef __GNUC__
-#define __GNUC___WORKAROUND_GUARD 1
-#else
-#define __GNUC___WORKAROUND_GUARD 0
-#endif
-#ifndef __GNUC_MINOR__
-#define __GNUC_MINOR___WORKAROUND_GUARD 1
-#else
-#define __GNUC_MINOR___WORKAROUND_GUARD 0
-#endif
-#ifndef __GNUC_PATCHLEVEL__
-#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 1
-#else
-#define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_GCC
-#define BOOST_GCC_WORKAROUND_GUARD 1
-#else
-#define BOOST_GCC_WORKAROUND_GUARD 0
-#endif
-#ifndef __IBMCPP__
-#define __IBMCPP___WORKAROUND_GUARD 1
-#else
-#define __IBMCPP___WORKAROUND_GUARD 0
-#endif
-#ifndef __SUNPRO_CC
-#define __SUNPRO_CC_WORKAROUND_GUARD 1
-#else
-#define __SUNPRO_CC_WORKAROUND_GUARD 0
-#endif
-#ifndef __DECCXX_VER
-#define __DECCXX_VER_WORKAROUND_GUARD 1
-#else
-#define __DECCXX_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef __MWERKS__
-#define __MWERKS___WORKAROUND_GUARD 1
-#else
-#define __MWERKS___WORKAROUND_GUARD 0
-#endif
-#ifndef __EDG__
-#define __EDG___WORKAROUND_GUARD 1
-#else
-#define __EDG___WORKAROUND_GUARD 0
-#endif
-#ifndef __EDG_VERSION__
-#define __EDG_VERSION___WORKAROUND_GUARD 1
-#else
-#define __EDG_VERSION___WORKAROUND_GUARD 0
-#endif
-#ifndef __HP_aCC
-#define __HP_aCC_WORKAROUND_GUARD 1
-#else
-#define __HP_aCC_WORKAROUND_GUARD 0
-#endif
-#ifndef __hpxstd98
-#define __hpxstd98_WORKAROUND_GUARD 1
-#else
-#define __hpxstd98_WORKAROUND_GUARD 0
-#endif
-#ifndef _CRAYC
-#define _CRAYC_WORKAROUND_GUARD 1
-#else
-#define _CRAYC_WORKAROUND_GUARD 0
-#endif
-#ifndef __DMC__
-#define __DMC___WORKAROUND_GUARD 1
-#else
-#define __DMC___WORKAROUND_GUARD 0
-#endif
-#ifndef MPW_CPLUS
-#define MPW_CPLUS_WORKAROUND_GUARD 1
-#else
-#define MPW_CPLUS_WORKAROUND_GUARD 0
-#endif
-#ifndef __COMO__
-#define __COMO___WORKAROUND_GUARD 1
-#else
-#define __COMO___WORKAROUND_GUARD 0
-#endif
-#ifndef __COMO_VERSION__
-#define __COMO_VERSION___WORKAROUND_GUARD 1
-#else
-#define __COMO_VERSION___WORKAROUND_GUARD 0
-#endif
-#ifndef __INTEL_COMPILER
-#define __INTEL_COMPILER_WORKAROUND_GUARD 1
-#else
-#define __INTEL_COMPILER_WORKAROUND_GUARD 0
-#endif
-#ifndef __ICL
-#define __ICL_WORKAROUND_GUARD 1
-#else
-#define __ICL_WORKAROUND_GUARD 0
-#endif
-#ifndef _COMPILER_VERSION
-#define _COMPILER_VERSION_WORKAROUND_GUARD 1
-#else
-#define _COMPILER_VERSION_WORKAROUND_GUARD 0
-#endif
-
-#ifndef _RWSTD_VER
-#define _RWSTD_VER_WORKAROUND_GUARD 1
-#else
-#define _RWSTD_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_RWSTD_VER
-#define BOOST_RWSTD_VER_WORKAROUND_GUARD 1
-#else
-#define BOOST_RWSTD_VER_WORKAROUND_GUARD 0
-#endif
-#ifndef __GLIBCPP__
-#define __GLIBCPP___WORKAROUND_GUARD 1
-#else
-#define __GLIBCPP___WORKAROUND_GUARD 0
-#endif
-#ifndef _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
-#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 1
-#else
-#define _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC_WORKAROUND_GUARD 0
-#endif
-#ifndef __SGI_STL_PORT
-#define __SGI_STL_PORT_WORKAROUND_GUARD 1
-#else
-#define __SGI_STL_PORT_WORKAROUND_GUARD 0
-#endif
-#ifndef _STLPORT_VERSION
-#define _STLPORT_VERSION_WORKAROUND_GUARD 1
-#else
-#define _STLPORT_VERSION_WORKAROUND_GUARD 0
-#endif
-#ifndef __LIBCOMO_VERSION__
-#define __LIBCOMO_VERSION___WORKAROUND_GUARD 1
-#else
-#define __LIBCOMO_VERSION___WORKAROUND_GUARD 0
-#endif
-#ifndef _CPPLIB_VER
-#define _CPPLIB_VER_WORKAROUND_GUARD 1
-#else
-#define _CPPLIB_VER_WORKAROUND_GUARD 0
-#endif
-
-#ifndef BOOST_INTEL_CXX_VERSION
-#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 1
-#else
-#define BOOST_INTEL_CXX_VERSION_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_INTEL_WIN
-#define BOOST_INTEL_WIN_WORKAROUND_GUARD 1
-#else
-#define BOOST_INTEL_WIN_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_DINKUMWARE_STDLIB
-#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 1
-#else
-#define BOOST_DINKUMWARE_STDLIB_WORKAROUND_GUARD 0
-#endif
-#ifndef BOOST_INTEL
-#define BOOST_INTEL_WORKAROUND_GUARD 1
-#else
-#define BOOST_INTEL_WORKAROUND_GUARD 0
-#endif
-// Always define to zero, if it's used it'll be defined my MPL:
-#define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
-
-#  define BOOST_WORKAROUND(symbol, test)                \
-         ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
-         (symbol != 0) && (1 % (( (symbol test) ) + 1)))
-//                              ^ ^           ^ ^
-// The extra level of parenthesis nesting above, along with the
-// BOOST_OPEN_PAREN indirection below, is required to satisfy the
-// broken preprocessor in MWCW 8.3 and earlier.
-//
-// The basic mechanism works as follows:
-//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
-//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
-//
-// The complication with % is for cooperation with BOOST_TESTED_AT().
-// When "test" is BOOST_TESTED_AT(x) and
-// BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
-//
-//      symbol test              =>   if (symbol <= x) then 1 else -1
-//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
-//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
-//
-
-#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
-#   define BOOST_OPEN_PAREN (
-#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
-#  else
-#   define BOOST_TESTED_AT(value) != ((value)-(value))
-#  endif
-
-# else
-
-#  define BOOST_WORKAROUND(symbol, test) 0
-
-# endif 
+#include <boost/config/workaround.hpp>
 
 #endif // WORKAROUND_DWA2002126_HPP
diff --git a/boost/functional/hash.hpp b/boost/functional/hash.hpp
new file mode 100644
index 0000000..44983f1
--- /dev/null
+++ b/boost/functional/hash.hpp
@@ -0,0 +1,7 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/functional/hash/hash.hpp>
+
diff --git a/boost/functional/hash/detail/float_functions.hpp b/boost/functional/hash/detail/float_functions.hpp
new file mode 100644
index 0000000..f3db52f
--- /dev/null
+++ b/boost/functional/hash/detail/float_functions.hpp
@@ -0,0 +1,336 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_FLOAT_FUNCTIONS_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/config/no_tr1/cmath.hpp>
+
+// Set BOOST_HASH_CONFORMANT_FLOATS to 1 for libraries known to have
+// sufficiently good floating point support to not require any
+// workarounds.
+//
+// When set to 0, the library tries to automatically
+// use the best available implementation. This normally works well, but
+// breaks when ambiguities are created by odd namespacing of the functions.
+//
+// Note that if this is set to 0, the library should still take full
+// advantage of the platform's floating point support.
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif defined(__LIBCOMO__)
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// Rogue Wave library:
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif defined(_LIBCPP_VERSION)
+// libc++
+#   define BOOST_HASH_CONFORMANT_FLOATS 1
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+// GNU libstdc++ 3
+#   if defined(__GNUC__) && __GNUC__ >= 4
+#       define BOOST_HASH_CONFORMANT_FLOATS 1
+#   else
+#       define BOOST_HASH_CONFORMANT_FLOATS 0
+#   endif
+#elif defined(__STL_CONFIG_H)
+// generic SGI STL
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif defined(__MSL_CPP__)
+// MSL standard lib:
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif defined(__IBMCPP__)
+// VACPP std lib (probably conformant for much earlier version).
+#   if __IBMCPP__ >= 1210
+#       define BOOST_HASH_CONFORMANT_FLOATS 1
+#   else
+#       define BOOST_HASH_CONFORMANT_FLOATS 0
+#   endif
+#elif defined(MSIPL_COMPILE_H)
+// Modena C++ standard library
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
+// Dinkumware Library (this has to appear after any possible replacement libraries):
+#   if _CPPLIB_VER >= 405
+#       define BOOST_HASH_CONFORMANT_FLOATS 1
+#   else
+#       define BOOST_HASH_CONFORMANT_FLOATS 0
+#   endif
+#else
+#   define BOOST_HASH_CONFORMANT_FLOATS 0
+#endif
+
+#if BOOST_HASH_CONFORMANT_FLOATS
+
+// The standard library is known to be compliant, so don't use the
+// configuration mechanism.
+
+namespace boost {
+    namespace hash_detail {
+        template <typename Float>
+        struct call_ldexp {
+            typedef Float float_type;
+            inline Float operator()(Float x, int y) const {
+                return std::ldexp(x, y);
+            }
+        };
+
+        template <typename Float>
+        struct call_frexp {
+            typedef Float float_type;
+            inline Float operator()(Float x, int* y) const {
+                return std::frexp(x, y);
+            }
+        };
+
+        template <typename Float>
+        struct select_hash_type
+        {
+            typedef Float type;
+        };
+    }
+}
+
+#else // BOOST_HASH_CONFORMANT_FLOATS == 0
+
+// The C++ standard requires that the C float functions are overloarded
+// for float, double and long double in the std namespace, but some of the older
+// library implementations don't support this. On some that don't, the C99
+// float functions (frexpf, frexpl, etc.) are available.
+//
+// The following tries to automatically detect which are available.
+
+namespace boost {
+    namespace hash_detail {
+
+        // Returned by dummy versions of the float functions.
+    
+        struct not_found {
+            // Implicitly convertible to float and long double in order to avoid
+            // a compile error when the dummy float functions are used.
+
+            inline operator float() const { return 0; }
+            inline operator long double() const { return 0; }
+        };
+          
+        // A type for detecting the return type of functions.
+
+        template <typename T> struct is;
+        template <> struct is<float> { char x[10]; };
+        template <> struct is<double> { char x[20]; };
+        template <> struct is<long double> { char x[30]; };
+        template <> struct is<boost::hash_detail::not_found> { char x[40]; };
+            
+        // Used to convert the return type of a function to a type for sizeof.
+
+        template <typename T> is<T> float_type(T);
+
+        // call_ldexp
+        //
+        // This will get specialized for float and long double
+        
+        template <typename Float> struct call_ldexp
+        {
+            typedef double float_type;
+            
+            inline double operator()(double a, int b) const
+            {
+                using namespace std;
+                return ldexp(a, b);
+            }
+        };
+
+        // call_frexp
+        //
+        // This will get specialized for float and long double
+
+        template <typename Float> struct call_frexp
+        {
+            typedef double float_type;
+            
+            inline double operator()(double a, int* b) const
+            {
+                using namespace std;
+                return frexp(a, b);
+            }
+        };
+    }
+}
+            
+// A namespace for dummy functions to detect when the actual function we want
+// isn't available. ldexpl, ldexpf etc. might be added tby the macros below.
+//
+// AFAICT these have to be outside of the boost namespace, as if they're in
+// the boost namespace they'll always be preferable to any other function
+// (since the arguments are built in types, ADL can't be used).
+
+namespace boost_hash_detect_float_functions {
+    template <class Float> boost::hash_detail::not_found ldexp(Float, int);
+    template <class Float> boost::hash_detail::not_found frexp(Float, int*);    
+}
+
+// Macros for generating specializations of call_ldexp and call_frexp.
+//
+// check_cpp and check_c99 check if the C++ or C99 functions are available.
+//
+// Then the call_* functions select an appropriate implementation.
+//
+// I used c99_func in a few places just to get a unique name.
+//
+// Important: when using 'using namespace' at namespace level, include as
+// little as possible in that namespace, as Visual C++ has an odd bug which
+// can cause the namespace to be imported at the global level. This seems to
+// happen mainly when there's a template in the same namesapce.
+
+#define BOOST_HASH_CALL_FLOAT_FUNC(cpp_func, c99_func, type1, type2)    \
+namespace boost_hash_detect_float_functions {                           \
+    template <class Float>                                              \
+    boost::hash_detail::not_found c99_func(Float, type2);               \
+}                                                                       \
+                                                                        \
+namespace boost {                                                       \
+    namespace hash_detail {                                             \
+        namespace c99_func##_detect {                                   \
+            using namespace std;                                        \
+            using namespace boost_hash_detect_float_functions;          \
+                                                                        \
+            struct check {                                              \
+                static type1 x;                                         \
+                static type2 y;                                         \
+                BOOST_STATIC_CONSTANT(bool, cpp =                       \
+                    sizeof(float_type(cpp_func(x,y)))                   \
+                        == sizeof(is<type1>));                          \
+                BOOST_STATIC_CONSTANT(bool, c99 =                       \
+                    sizeof(float_type(c99_func(x,y)))                   \
+                        == sizeof(is<type1>));                          \
+            };                                                          \
+        }                                                               \
+                                                                        \
+        template <bool x>                                               \
+        struct call_c99_##c99_func :                                    \
+            boost::hash_detail::call_##cpp_func<double> {};             \
+                                                                        \
+        template <>                                                     \
+        struct call_c99_##c99_func<true> {                              \
+            typedef type1 float_type;                                   \
+                                                                        \
+            template <typename T>                                       \
+            inline type1 operator()(type1 a, T b)  const                \
+            {                                                           \
+                using namespace std;                                    \
+                return c99_func(a, b);                                  \
+            }                                                           \
+        };                                                              \
+                                                                        \
+        template <bool x>                                               \
+        struct call_cpp_##c99_func :                                    \
+            call_c99_##c99_func<                                        \
+                ::boost::hash_detail::c99_func##_detect::check::c99     \
+            > {};                                                       \
+                                                                        \
+        template <>                                                     \
+        struct call_cpp_##c99_func<true> {                              \
+            typedef type1 float_type;                                   \
+                                                                        \
+            template <typename T>                                       \
+            inline type1 operator()(type1 a, T b)  const                \
+            {                                                           \
+                using namespace std;                                    \
+                return cpp_func(a, b);                                  \
+            }                                                           \
+        };                                                              \
+                                                                        \
+        template <>                                                     \
+        struct call_##cpp_func<type1> :                                 \
+            call_cpp_##c99_func<                                        \
+                ::boost::hash_detail::c99_func##_detect::check::cpp     \
+            > {};                                                       \
+    }                                                                   \
+}
+
+#define BOOST_HASH_CALL_FLOAT_MACRO(cpp_func, c99_func, type1, type2)   \
+namespace boost {                                                       \
+    namespace hash_detail {                                             \
+                                                                        \
+        template <>                                                     \
+        struct call_##cpp_func<type1> {                                 \
+            typedef type1 float_type;                                   \
+            inline type1 operator()(type1 x, type2 y) const {           \
+                return c99_func(x, y);                                  \
+            }                                                           \
+        };                                                              \
+    }                                                                   \
+}
+
+#if defined(ldexpf)
+BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpf, float, int)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpf, float, int)
+#endif
+
+#if defined(ldexpl)
+BOOST_HASH_CALL_FLOAT_MACRO(ldexp, ldexpl, long double, int)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(ldexp, ldexpl, long double, int)
+#endif
+
+#if defined(frexpf)
+BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpf, float, int*)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpf, float, int*)
+#endif
+
+#if defined(frexpl)
+BOOST_HASH_CALL_FLOAT_MACRO(frexp, frexpl, long double, int*)
+#else
+BOOST_HASH_CALL_FLOAT_FUNC(frexp, frexpl, long double, int*)
+#endif
+
+#undef BOOST_HASH_CALL_FLOAT_MACRO
+#undef BOOST_HASH_CALL_FLOAT_FUNC
+
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <typename Float1, typename Float2>
+        struct select_hash_type_impl {
+            typedef double type;
+        };
+
+        template <>
+        struct select_hash_type_impl<float, float> {
+            typedef float type;
+        };
+
+        template <>
+        struct select_hash_type_impl<long double, long double> {
+            typedef long double type;
+        };
+
+
+        // select_hash_type
+        //
+        // If there is support for a particular floating point type, use that
+        // otherwise use double (there's always support for double).
+             
+        template <typename Float>
+        struct select_hash_type : select_hash_type_impl<
+                BOOST_DEDUCED_TYPENAME call_ldexp<Float>::float_type,
+                BOOST_DEDUCED_TYPENAME call_frexp<Float>::float_type
+            > {};            
+    }
+}
+
+#endif // BOOST_HASH_CONFORMANT_FLOATS
+
+#endif
diff --git a/boost/functional/hash/detail/hash_float.hpp b/boost/functional/hash/detail/hash_float.hpp
new file mode 100644
index 0000000..1816c57
--- /dev/null
+++ b/boost/functional/hash/detail/hash_float.hpp
@@ -0,0 +1,271 @@
+
+// Copyright 2005-2012 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_HASH_FLOAT_HEADER
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash/detail/float_functions.hpp>
+#include <boost/functional/hash/detail/limits.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/integer/static_log2.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+#include <boost/limits.hpp>
+#include <cstring>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6294) // Ill-defined for-loop: initial condition does
+                              // not satisfy test. Loop body not executed
+#endif
+#endif
+
+// Can we use fpclassify?
+
+// STLport
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define BOOST_HASH_USE_FPCLASSIFY 0
+
+// GNU libstdc++ 3
+#elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
+#  if (defined(__USE_ISOC99) || defined(_GLIBCXX_USE_C99_MATH)) && \
+      !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))
+#    define BOOST_HASH_USE_FPCLASSIFY 1
+#  else
+#    define BOOST_HASH_USE_FPCLASSIFY 0
+#  endif
+
+// Everything else
+#else
+#  define BOOST_HASH_USE_FPCLASSIFY 0
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        inline void hash_float_combine(std::size_t& seed, std::size_t value)
+        {
+            seed ^= value + (seed<<6) + (seed>>2);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Binary hash function
+        //
+        // Only used for floats with known iec559 floats, and certain values in
+        // numeric_limits
+
+        inline std::size_t hash_binary(char* ptr, std::size_t length)
+        {
+            std::size_t seed = 0;
+
+            if (length >= sizeof(std::size_t)) {
+                std::memcpy(&seed, ptr, sizeof(std::size_t));
+                length -= sizeof(std::size_t);
+                ptr += sizeof(std::size_t);
+
+                while(length >= sizeof(std::size_t)) {
+                    std::size_t buffer = 0;
+                    std::memcpy(&buffer, ptr, sizeof(std::size_t));
+                    hash_float_combine(seed, buffer);
+                    length -= sizeof(std::size_t);
+                    ptr += sizeof(std::size_t);
+                }
+            }
+
+            if (length > 0) {
+                std::size_t buffer = 0;
+                std::memcpy(&buffer, ptr, length);
+                hash_float_combine(seed, buffer);
+            }
+
+            return seed;
+        }
+
+        template <typename Float, unsigned digits, unsigned max_exponent>
+        struct enable_binary_hash
+        {
+            BOOST_STATIC_CONSTANT(bool, value =
+                std::numeric_limits<Float>::is_iec559 &&
+                std::numeric_limits<Float>::digits == digits &&
+                std::numeric_limits<Float>::radix == 2 &&
+                std::numeric_limits<Float>::max_exponent == max_exponent);
+        };
+
+        template <typename Float>
+        inline std::size_t float_hash_impl(Float v,
+            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
+                enable_binary_hash<Float, 24, 128>::value,
+                std::size_t>::type)
+        {
+            return hash_binary((char*) &v, 4);
+        }
+
+
+        template <typename Float>
+        inline std::size_t float_hash_impl(Float v,
+            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
+                enable_binary_hash<Float, 53, 1024>::value,
+                std::size_t>::type)
+        {
+            return hash_binary((char*) &v, 8);
+        }
+
+        template <typename Float>
+        inline std::size_t float_hash_impl(Float v,
+            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
+                enable_binary_hash<Float, 64, 16384>::value,
+                std::size_t>::type)
+        {
+            return hash_binary((char*) &v, 10);
+        }
+
+        template <typename Float>
+        inline std::size_t float_hash_impl(Float v,
+            BOOST_DEDUCED_TYPENAME boost::enable_if_c<
+                enable_binary_hash<Float, 113, 16384>::value,
+                std::size_t>::type)
+        {
+            return hash_binary((char*) &v, 16);
+        }
+
+        ////////////////////////////////////////////////////////////////////////
+        // Portable hash function
+        //
+        // Used as a fallback when the binary hash function isn't supported.
+
+        template <class T>
+        inline std::size_t float_hash_impl2(T v)
+        {
+            boost::hash_detail::call_frexp<T> frexp;
+            boost::hash_detail::call_ldexp<T> ldexp;
+
+            int exp = 0;
+
+            v = frexp(v, &exp);
+
+            // A postive value is easier to hash, so combine the
+            // sign with the exponent and use the absolute value.
+            if(v < 0) {
+                v = -v;
+                exp += limits<T>::max_exponent -
+                    limits<T>::min_exponent;
+            }
+
+            v = ldexp(v, limits<std::size_t>::digits);
+            std::size_t seed = static_cast<std::size_t>(v);
+            v -= static_cast<T>(seed);
+
+            // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
+            std::size_t const length
+                = (limits<T>::digits *
+                        boost::static_log2<limits<T>::radix>::value
+                        + limits<std::size_t>::digits - 1)
+                / limits<std::size_t>::digits;
+
+            for(std::size_t i = 0; i != length; ++i)
+            {
+                v = ldexp(v, limits<std::size_t>::digits);
+                std::size_t part = static_cast<std::size_t>(v);
+                v -= static_cast<T>(part);
+                hash_float_combine(seed, part);
+            }
+
+            hash_float_combine(seed, static_cast<std::size_t>(exp));
+
+            return seed;
+        }
+
+#if !defined(BOOST_HASH_DETAIL_TEST_WITHOUT_GENERIC)
+        template <class T>
+        inline std::size_t float_hash_impl(T v, ...)
+        {
+            typedef BOOST_DEDUCED_TYPENAME select_hash_type<T>::type type;
+            return float_hash_impl2(static_cast<type>(v));
+        }
+#endif
+    }
+}
+
+#if BOOST_HASH_USE_FPCLASSIFY
+
+#include <boost/config/no_tr1/cmath.hpp>
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t float_hash_value(T v)
+        {
+#if defined(fpclassify)
+            switch (fpclassify(v))
+#elif BOOST_HASH_CONFORMANT_FLOATS
+            switch (std::fpclassify(v))
+#else
+            using namespace std;
+            switch (fpclassify(v))
+#endif
+            {
+            case FP_ZERO:
+                return 0;
+            case FP_INFINITE:
+                return (std::size_t)(v > 0 ? -1 : -2);
+            case FP_NAN:
+                return (std::size_t)(-3);
+            case FP_NORMAL:
+            case FP_SUBNORMAL:
+                return float_hash_impl(v, 0);
+            default:
+                BOOST_ASSERT(0);
+                return 0;
+            }
+        }
+    }
+}
+
+#else // !BOOST_HASH_USE_FPCLASSIFY
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        inline bool is_zero(T v)
+        {
+#if !defined(__GNUC__) && !defined(__clang__)
+            return v == 0;
+#else
+            // GCC's '-Wfloat-equal' will complain about comparing
+            // v to 0, but because it disables warnings for system
+            // headers it won't complain if you use std::equal_to to
+            // compare with 0. Resulting in this silliness:
+            return std::equal_to<T>()(v, 0);
+#endif
+        }
+
+        template <class T>
+        inline std::size_t float_hash_value(T v)
+        {
+            return boost::hash_detail::is_zero(v) ? 0 : float_hash_impl(v, 0);
+        }
+    }
+}
+
+#endif // BOOST_HASH_USE_FPCLASSIFY
+
+#undef BOOST_HASH_USE_FPCLASSIFY
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/boost/functional/hash/detail/limits.hpp b/boost/functional/hash/detail/limits.hpp
new file mode 100644
index 0000000..4a971a6
--- /dev/null
+++ b/boost/functional/hash/detail/limits.hpp
@@ -0,0 +1,62 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// On some platforms std::limits gives incorrect values for long double.
+// This tries to work around them.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER)
+#define BOOST_FUNCTIONAL_HASH_DETAIL_LIMITS_HEADER
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/limits.hpp>
+
+// On OpenBSD, numeric_limits is not reliable for long doubles, but
+// the macros defined in <float.h> are and support long double when STLport
+// doesn't.
+
+#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
+#include <float.h>
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+        template <class T>
+        struct limits : std::numeric_limits<T> {};
+
+#if defined(__OpenBSD__) || defined(_STLP_NO_LONG_DOUBLE)
+        template <>
+        struct limits<long double>
+             : std::numeric_limits<long double>
+        {
+            static long double epsilon() {
+                return LDBL_EPSILON;
+            }
+
+            static long double (max)() {
+                return LDBL_MAX;
+            }
+
+            static long double (min)() {
+                return LDBL_MIN;
+            }
+
+            BOOST_STATIC_CONSTANT(int, digits = LDBL_MANT_DIG);
+            BOOST_STATIC_CONSTANT(int, max_exponent = LDBL_MAX_EXP);
+            BOOST_STATIC_CONSTANT(int, min_exponent = LDBL_MIN_EXP);
+#if defined(_STLP_NO_LONG_DOUBLE)
+            BOOST_STATIC_CONSTANT(int, radix = FLT_RADIX);
+#endif
+        };
+#endif // __OpenBSD__
+    }
+}
+
+#endif
diff --git a/boost/functional/hash/extensions.hpp b/boost/functional/hash/extensions.hpp
new file mode 100644
index 0000000..cb3c856
--- /dev/null
+++ b/boost/functional/hash/extensions.hpp
@@ -0,0 +1,318 @@
+
+// Copyright 2005-2009 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18. 
+
+// This implements the extensions to the standard.
+// It's undocumented, so you shouldn't use it....
+
+#if !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
+#define BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash/hash.hpp>
+#include <boost/detail/container_fwd.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+#   include <array>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   include <tuple>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_MEMORY)
+#   include <memory>
+#endif
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+#include <boost/type_traits/is_array.hpp>
+#endif
+
+namespace boost
+{
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const&);
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v);
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v);
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v);
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v);
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const&);
+
+    template <class A, class B>
+    std::size_t hash_value(std::pair<A, B> const& v)
+    {
+        std::size_t seed = 0;
+        boost::hash_combine(seed, v.first);
+        boost::hash_combine(seed, v.second);
+        return seed;
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::vector<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::list<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T, class A>
+    std::size_t hash_value(std::deque<T, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::set<K, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class C, class A>
+    std::size_t hash_value(std::multiset<K, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::map<K, T, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class K, class T, class C, class A>
+    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+
+    template <class T>
+    std::size_t hash_value(std::complex<T> const& v)
+    {
+        boost::hash<T> hasher;
+        std::size_t seed = hasher(v.imag());
+        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
+        return seed;
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_ARRAY)
+    template <class T, std::size_t N>
+    std::size_t hash_value(std::array<T, N> const& v)
+    {
+        return boost::hash_range(v.begin(), v.end());
+    }
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE)
+    namespace hash_detail {
+        template <std::size_t I, typename T>
+        inline typename boost::enable_if_c<(I == std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t&, T const&)
+        {
+        }
+
+        template <std::size_t I, typename T>
+        inline typename boost::enable_if_c<(I < std::tuple_size<T>::value),
+                void>::type
+            hash_combine_tuple(std::size_t& seed, T const& v)
+        {
+            boost::hash_combine(seed, std::get<I>(v));
+            boost::hash_detail::hash_combine_tuple<I + 1>(seed, v);
+        }
+
+        template <typename T>
+        inline std::size_t hash_tuple(T const& v)
+        {
+            std::size_t seed = 0;
+            boost::hash_detail::hash_combine_tuple<0>(seed, v);
+            return seed;
+        }
+    }
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template <typename... T>
+    inline std::size_t hash_value(std::tuple<T...> const& v)
+    {
+        return boost::hash_detail::hash_tuple(v);
+    }
+#else
+
+    inline std::size_t hash_value(std::tuple<> const& v)
+    {
+        return boost::hash_detail::hash_tuple(v);
+    }
+
+#   define BOOST_HASH_TUPLE_F(z, n, _)                                      \
+    template<                                                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)                            \
+    >                                                                       \
+    inline std::size_t hash_value(std::tuple<                               \
+        BOOST_PP_ENUM_PARAMS_Z(z, n, A)                                     \
+    > const& v)                                                             \
+    {                                                                       \
+        return boost::hash_detail::hash_tuple(v);                           \
+    }
+
+    BOOST_PP_REPEAT_FROM_TO(1, 11, BOOST_HASH_TUPLE_F, _)
+#   undef BOOST_HASH_TUPLE_F
+#endif
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_SMART_PTR)
+    template <typename T>
+    inline std::size_t hash_value(std::shared_ptr<T> const& x) {
+        return boost::hash_value(x.get());
+    }
+
+    template <typename T, typename Deleter>
+    inline std::size_t hash_value(std::unique_ptr<T, Deleter> const& x) {
+        return boost::hash_value(x.get());
+    }
+#endif
+
+    //
+    // call_hash_impl
+    //
+
+    // On compilers without function template ordering, this deals with arrays.
+
+#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    namespace hash_detail
+    {
+        template <bool IsArray>
+        struct call_hash_impl
+        {
+            template <class T>
+            struct inner
+            {
+                static std::size_t call(T const& v)
+                {
+                    using namespace boost;
+                    return hash_value(v);
+                }
+            };
+        };
+
+        template <>
+        struct call_hash_impl<true>
+        {
+            template <class Array>
+            struct inner
+            {
+                static std::size_t call(Array const& v)
+                {
+                    const int size = sizeof(v) / sizeof(*v);
+                    return boost::hash_range(v, v + size);
+                }
+            };
+        };
+
+        template <class T>
+        struct call_hash
+            : public call_hash_impl<boost::is_array<T>::value>
+                ::BOOST_NESTED_TEMPLATE inner<T>
+        {
+        };
+    }
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+    //
+    // boost::hash
+    //
+
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+    template <class T> struct hash
+        : boost::hash_detail::hash_base<T>
+    {
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+        std::size_t operator()(T const& val) const
+        {
+            return hash_value(val);
+        }
+#else
+        std::size_t operator()(T const& val) const
+        {
+            return hash_detail::call_hash<T>::call(val);
+        }
+#endif
+    };
+
+#if BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T, unsigned int n> struct hash<T[n]>
+        : boost::hash_detail::hash_base<T[n]>
+    {
+        std::size_t operator()(const T* val) const
+        {
+            return boost::hash_range(val, val+n);
+        }
+    };
+#endif
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+    // On compilers without partial specialization, boost::hash<T>
+    // has already been declared to deal with pointers, so just
+    // need to supply the non-pointer version of hash_impl.
+
+    namespace hash_detail
+    {
+        template <bool IsPointer>
+        struct hash_impl;
+
+        template <>
+        struct hash_impl<false>
+        {
+            template <class T>
+            struct inner
+                : boost::hash_detail::hash_base<T>
+            {
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+                std::size_t operator()(T const& val) const
+                {
+                    return hash_value(val);
+                }
+#else
+                std::size_t operator()(T const& val) const
+                {
+                    return hash_detail::call_hash<T>::call(val);
+                }
+#endif
+            };
+        };
+    }
+#endif  // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+}
+
+#endif
diff --git a/boost/functional/hash/hash.hpp b/boost/functional/hash/hash.hpp
new file mode 100644
index 0000000..b461f5f
--- /dev/null
+++ b/boost/functional/hash/hash.hpp
@@ -0,0 +1,595 @@
+
+// Copyright 2005-2014 Daniel James.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  Based on Peter Dimov's proposal
+//  http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1756.pdf
+//  issue 6.18. 
+//
+//  This also contains public domain code from MurmurHash. From the
+//  MurmurHash header:
+
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#if !defined(BOOST_FUNCTIONAL_HASH_HASH_HPP)
+#define BOOST_FUNCTIONAL_HASH_HASH_HPP
+
+#include <boost/functional/hash/hash_fwd.hpp>
+#include <functional>
+#include <boost/functional/hash/detail/hash_float.hpp>
+#include <string>
+#include <boost/limits.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/cstdint.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#include <boost/type_traits/is_pointer.hpp>
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+#include <typeindex>
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+
+#if BOOST_MSVC >= 1400
+#pragma warning(disable:6295) // Ill-defined for-loop : 'unsigned int' values
+                              // are always of range '0' to '4294967295'.
+                              // Loop executes infinitely.
+#endif
+
+#endif
+
+#if BOOST_WORKAROUND(__GNUC__, < 3) \
+    && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION)
+#define BOOST_HASH_CHAR_TRAITS string_char_traits
+#else
+#define BOOST_HASH_CHAR_TRAITS char_traits
+#endif
+
+#if defined(_MSC_VER)
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) _rotl(x,r)
+#else
+#   define BOOST_FUNCTIONAL_HASH_ROTL32(x, r) (x << r) | (x >> (32 - r))
+#endif
+
+namespace boost
+{
+    namespace hash_detail
+    {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+        template <typename T>
+        struct hash_base
+        {
+            typedef T argument_type;
+            typedef std::size_t result_type;
+        };
+#else
+        template <typename T>
+        struct hash_base : std::unary_function<T, std::size_t> {};
+#endif
+
+        struct enable_hash_value { typedef std::size_t type; };
+
+        template <typename T> struct basic_numbers {};
+        template <typename T> struct long_numbers;
+        template <typename T> struct ulong_numbers;
+        template <typename T> struct float_numbers {};
+
+        template <> struct basic_numbers<bool> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<signed char> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<short> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned short> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<int> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned int> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<long> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct basic_numbers<unsigned long> :
+            boost::hash_detail::enable_hash_value {};
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+        template <> struct basic_numbers<wchar_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+        template <> struct basic_numbers<char16_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+        template <> struct basic_numbers<char32_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+        // long_numbers is defined like this to allow for separate
+        // specialization for long_long and int128_type, in case
+        // they conflict.
+        template <typename T> struct long_numbers2 {};
+        template <typename T> struct ulong_numbers2 {};
+        template <typename T> struct long_numbers : long_numbers2<T> {};
+        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};
+
+#if !defined(BOOST_NO_LONG_LONG)
+        template <> struct long_numbers<boost::long_long_type> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct ulong_numbers<boost::ulong_long_type> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if defined(BOOST_HAS_INT128)
+        template <> struct long_numbers2<boost::int128_type> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct ulong_numbers2<boost::uint128_type> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+        template <> struct float_numbers<float> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct float_numbers<double> :
+            boost::hash_detail::enable_hash_value {};
+        template <> struct float_numbers<long double> :
+            boost::hash_detail::enable_hash_value {};
+    }
+
+    template <typename T>
+    typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
+    template <typename T>
+    typename boost::hash_detail::long_numbers<T>::type hash_value(T);
+    template <typename T>
+    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);
+
+    template <typename T>
+    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
+        hash_value(T);
+
+#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T> std::size_t hash_value(T* const&);
+#else
+    template <class T> std::size_t hash_value(T*);
+#endif
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    std::size_t hash_value(const T (&x)[N]);
+
+    template< class T, unsigned N >
+    std::size_t hash_value(T (&x)[N]);
+#endif
+
+    template <class Ch, class A>
+    std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const&);
+
+    template <typename T>
+    typename boost::hash_detail::float_numbers<T>::type hash_value(T);
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    std::size_t hash_value(std::type_index);
+#endif
+
+    // Implementation
+
+    namespace hash_detail
+    {
+        template <class T>
+        inline std::size_t hash_value_signed(T val)
+        {
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
+             const int length = (std::numeric_limits<T>::digits - 1)
+                 / static_cast<int>(size_t_bits);
+
+             std::size_t seed = 0;
+             T positive = val < 0 ? -1 - val : val;
+
+             // Hopefully, this loop can be unrolled.
+             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
+             {
+                 seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
+             }
+             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
+
+             return seed;
+        }
+
+        template <class T>
+        inline std::size_t hash_value_unsigned(T val)
+        {
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
+             const int length = (std::numeric_limits<T>::digits - 1)
+                 / static_cast<int>(size_t_bits);
+
+             std::size_t seed = 0;
+
+             // Hopefully, this loop can be unrolled.
+             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
+             {
+                 seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
+             }
+             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);
+
+             return seed;
+        }
+
+        template <typename SizeT>
+        inline void hash_combine_impl(SizeT& seed, SizeT value)
+        {
+            seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        inline void hash_combine_impl(boost::uint32_t& h1,
+                boost::uint32_t k1)
+        {
+            const uint32_t c1 = 0xcc9e2d51;
+            const uint32_t c2 = 0x1b873593;
+
+            k1 *= c1;
+            k1 = BOOST_FUNCTIONAL_HASH_ROTL32(k1,15);
+            k1 *= c2;
+
+            h1 ^= k1;
+            h1 = BOOST_FUNCTIONAL_HASH_ROTL32(h1,13);
+            h1 = h1*5+0xe6546b64;
+        }
+
+
+// Don't define 64-bit hash combine on platforms without 64 bit integers,
+// and also not for 32-bit gcc as it warns about the 64-bit constant.
+#if !defined(BOOST_NO_INT64_T) && \
+        !(defined(__GNUC__) && ULONG_MAX == 0xffffffff)
+
+        inline void hash_combine_impl(boost::uint64_t& h,
+                boost::uint64_t k)
+        {
+            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+            const int r = 47;
+
+            k *= m;
+            k ^= k >> r;
+            k *= m;
+
+            h ^= k;
+            h *= m;
+
+            // Completely arbitrary number, to prevent 0's
+            // from hashing to 0.
+            h += 0xe6546b64;
+        }
+
+#endif // BOOST_NO_INT64_T
+    }
+
+    template <typename T>
+    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    template <typename T>
+    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
+    {
+        return hash_detail::hash_value_signed(v);
+    }
+
+    template <typename T>
+    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
+    {
+        return hash_detail::hash_value_unsigned(v);
+    }
+
+    template <typename T>
+    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
+        hash_value(T v)
+    {
+        return static_cast<std::size_t>(v);
+    }
+
+    // Implementation by Alberto Barbati and Dave Harris.
+#if !BOOST_WORKAROUND(__DMC__, <= 0x848)
+    template <class T> std::size_t hash_value(T* const& v)
+#else
+    template <class T> std::size_t hash_value(T* v)
+#endif
+    {
+#if defined(__VMS) && __INITIAL_POINTER_SIZE == 64
+    // for some reason ptrdiff_t on OpenVMS compiler with
+    // 64 bit is not 64 bit !!!
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<long long int>(v));
+#else
+        std::size_t x = static_cast<std::size_t>(
+           reinterpret_cast<std::ptrdiff_t>(v));
+#endif
+        return x + (x >> 3);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#if BOOST_MSVC <= 1400
+#pragma warning(disable:4267) // 'argument' : conversion from 'size_t' to
+                              // 'unsigned int', possible loss of data
+                              // A misguided attempt to detect 64-bit
+                              // incompatability.
+#endif
+#endif
+
+    template <class T>
+    inline void hash_combine(std::size_t& seed, T const& v)
+    {
+        boost::hash<T> hasher;
+        return boost::hash_detail::hash_combine_impl(seed, hasher(v));
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+    template <class It>
+    inline std::size_t hash_range(It first, It last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+
+        return seed;
+    }
+
+    template <class It>
+    inline void hash_range(std::size_t& seed, It first, It last)
+    {
+        for(; first != last; ++first)
+        {
+            hash_combine(seed, *first);
+        }
+    }
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
+    template <class T>
+    inline std::size_t hash_range(T* first, T* last)
+    {
+        std::size_t seed = 0;
+
+        for(; first != last; ++first)
+        {
+            boost::hash<T> hasher;
+            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+
+        return seed;
+    }
+
+    template <class T>
+    inline void hash_range(std::size_t& seed, T* first, T* last)
+    {
+        for(; first != last; ++first)
+        {
+            boost::hash<T> hasher;
+            seed ^= hasher(*first) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+        }
+    }
+#endif
+
+#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+    template< class T, unsigned N >
+    inline std::size_t hash_value(const T (&x)[N])
+    {
+        return hash_range(x, x + N);
+    }
+
+    template< class T, unsigned N >
+    inline std::size_t hash_value(T (&x)[N])
+    {
+        return hash_range(x, x + N);
+    }
+#endif
+
+    template <class Ch, class A>
+    inline std::size_t hash_value(
+        std::basic_string<Ch, std::BOOST_HASH_CHAR_TRAITS<Ch>, A> const& v)
+    {
+        return hash_range(v.begin(), v.end());
+    }
+
+    template <typename T>
+    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
+    {
+        return boost::hash_detail::float_hash_value(v);
+    }
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    inline std::size_t hash_value(std::type_index v)
+    {
+        return v.hash_code();
+    }
+#endif
+
+    //
+    // boost::hash
+    //
+    
+    // Define the specializations required by the standard. The general purpose
+    // boost::hash is defined later in extensions.hpp if
+    // BOOST_HASH_NO_EXTENSIONS is not defined.
+    
+    // BOOST_HASH_SPECIALIZE - define a specialization for a type which is
+    // passed by copy.
+    //
+    // BOOST_HASH_SPECIALIZE_REF - define a specialization for a type which is
+    // passed by const reference.
+    //
+    // These are undefined later.
+
+#define BOOST_HASH_SPECIALIZE(type) \
+    template <> struct hash<type> \
+         : public boost::hash_detail::hash_base<type> \
+    { \
+        std::size_t operator()(type v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+
+#define BOOST_HASH_SPECIALIZE_REF(type) \
+    template <> struct hash<type> \
+         : public boost::hash_detail::hash_base<type> \
+    { \
+        std::size_t operator()(type const& v) const \
+        { \
+            return boost::hash_value(v); \
+        } \
+    };
+
+    BOOST_HASH_SPECIALIZE(bool)
+    BOOST_HASH_SPECIALIZE(char)
+    BOOST_HASH_SPECIALIZE(signed char)
+    BOOST_HASH_SPECIALIZE(unsigned char)
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_HASH_SPECIALIZE(wchar_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE(char16_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE(char32_t)
+#endif
+    BOOST_HASH_SPECIALIZE(short)
+    BOOST_HASH_SPECIALIZE(unsigned short)
+    BOOST_HASH_SPECIALIZE(int)
+    BOOST_HASH_SPECIALIZE(unsigned int)
+    BOOST_HASH_SPECIALIZE(long)
+    BOOST_HASH_SPECIALIZE(unsigned long)
+
+    BOOST_HASH_SPECIALIZE(float)
+    BOOST_HASH_SPECIALIZE(double)
+    BOOST_HASH_SPECIALIZE(long double)
+
+    BOOST_HASH_SPECIALIZE_REF(std::string)
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_HASH_SPECIALIZE_REF(std::wstring)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
+#endif
+
+#if !defined(BOOST_NO_LONG_LONG)
+    BOOST_HASH_SPECIALIZE(boost::long_long_type)
+    BOOST_HASH_SPECIALIZE(boost::ulong_long_type)
+#endif
+
+#if defined(BOOST_HAS_INT128)
+    BOOST_HASH_SPECIALIZE(boost::int128_type)
+    BOOST_HASH_SPECIALIZE(boost::uint128_type)
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPEINDEX)
+    BOOST_HASH_SPECIALIZE(std::type_index)
+#endif
+
+#undef BOOST_HASH_SPECIALIZE
+#undef BOOST_HASH_SPECIALIZE_REF
+
+// Specializing boost::hash for pointers.
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+    template <class T>
+    struct hash<T*>
+        : public boost::hash_detail::hash_base<T*>
+    {
+        std::size_t operator()(T* v) const
+        {
+#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590)
+            return boost::hash_value(v);
+#else
+            std::size_t x = static_cast<std::size_t>(
+                reinterpret_cast<std::ptrdiff_t>(v));
+
+            return x + (x >> 3);
+#endif
+        }
+    };
+
+#else
+
+    // For compilers without partial specialization, we define a
+    // boost::hash for all remaining types. But hash_impl is only defined
+    // for pointers in 'extensions.hpp' - so when BOOST_HASH_NO_EXTENSIONS
+    // is defined there will still be a compile error for types not supported
+    // in the standard.
+
+    namespace hash_detail
+    {
+        template <bool IsPointer>
+        struct hash_impl;
+
+        template <>
+        struct hash_impl<true>
+        {
+            template <class T>
+            struct inner
+                : public boost::hash_detail::hash_base<T>
+            {
+                std::size_t operator()(T val) const
+                {
+#if !BOOST_WORKAROUND(__SUNPRO_CC, <= 590)
+                    return boost::hash_value(val);
+#else
+                    std::size_t x = static_cast<std::size_t>(
+                        reinterpret_cast<std::ptrdiff_t>(val));
+
+                    return x + (x >> 3);
+#endif
+                }
+            };
+        };
+    }
+
+    template <class T> struct hash
+        : public boost::hash_detail::hash_impl<boost::is_pointer<T>::value>
+            ::BOOST_NESTED_TEMPLATE inner<T>
+    {
+    };
+
+#endif
+}
+
+#undef BOOST_HASH_CHAR_TRAITS
+#undef BOOST_FUNCTIONAL_HASH_ROTL32
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_FUNCTIONAL_HASH_HASH_HPP
+
+// Include this outside of the include guards in case the file is included
+// twice - once with BOOST_HASH_NO_EXTENSIONS defined, and then with it
+// undefined.
+
+#if !defined(BOOST_HASH_NO_EXTENSIONS) \
+    && !defined(BOOST_FUNCTIONAL_HASH_EXTENSIONS_HPP)
+#include <boost/functional/hash/extensions.hpp>
+#endif
diff --git a/boost/icl/detail/element_iterator.hpp b/boost/icl/detail/element_iterator.hpp
index 111f209..d01cea3 100644
--- a/boost/icl/detail/element_iterator.hpp
+++ b/boost/icl/detail/element_iterator.hpp
@@ -89,7 +89,7 @@ struct elemental;
 
     template< class DomainT, class CodomainT, 
               ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval >
-    struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+    struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare) const, CodomainT> >
     {
         typedef std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type;
         typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare)                       interval_type;
@@ -113,7 +113,7 @@ struct elemental;
     };
 
     template< class CodomainT, ICL_INTERVAL(ICL_COMPARE) Interval >
-    struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+    struct elemental<std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare) const, CodomainT> >
     {
         typedef std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare), CodomainT> segment_type;
         typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare)                       interval_type;
@@ -161,7 +161,7 @@ struct segment_adapter<SegmentIteratorT, ICL_INTERVAL_TYPE(Interval,DomainT,Comp
 
 template < class SegmentIteratorT, class DomainT, class CodomainT, 
            ICL_COMPARE Compare, ICL_INTERVAL(ICL_COMPARE) Interval >
-struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare) const, CodomainT> >
 {
     typedef segment_adapter                         type;
     typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare)               interval_type;
@@ -214,7 +214,7 @@ struct segment_adapter
 };
 
 template < class SegmentIteratorT, class CodomainT, ICL_INTERVAL(ICL_COMPARE) Interval >
-struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare)const, CodomainT> >
+struct segment_adapter<SegmentIteratorT, std::pair<ICL_INTERVAL_TYPE(Interval,DomainT,Compare) const, CodomainT> >
 {
     typedef segment_adapter                                type;
     typedef ICL_INTERVAL_TYPE(Interval,DomainT,Compare)    interval_type;
diff --git a/boost/icl/functors.hpp b/boost/icl/functors.hpp
index 2401b2b..b4971f4 100644
--- a/boost/icl/functors.hpp
+++ b/boost/icl/functors.hpp
@@ -8,7 +8,6 @@ Copyright (c) 2007-2009: Joachim Faulhaber
 #ifndef BOOST_ICL_FUNCTORS_HPP_JOFA_080315
 #define BOOST_ICL_FUNCTORS_HPP_JOFA_080315
 
-#include <functional>
 #include <boost/type_traits.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/icl/type_traits/identity_element.hpp>
@@ -20,15 +19,19 @@ namespace boost{namespace icl
 {
     // ------------------------------------------------------------------------
     template <typename Type> struct identity_based_inplace_combine 
-        : public std::binary_function<Type&, const Type&, void>
     {
+        typedef Type& first_argument_type;
+        typedef const Type& second_argument_type;
+        typedef void result_type;
         inline static Type identity_element() { return boost::icl::identity_element<Type>::value(); }
     };
 
     // ------------------------------------------------------------------------
     template <typename Type> struct unit_element_based_inplace_combine 
-        : public std::binary_function<Type&, const Type&, void>
     {
+        typedef Type& first_argument_type;
+        typedef const Type& second_argument_type;
+        typedef void result_type;
         inline static Type identity_element() { return boost::icl::unit_element<Type>::value(); }
     };
 
diff --git a/boost/icl/interval_bounds.hpp b/boost/icl/interval_bounds.hpp
index edf16d0..f917cb6 100644
--- a/boost/icl/interval_bounds.hpp
+++ b/boost/icl/interval_bounds.hpp
@@ -41,8 +41,8 @@ public:
     interval_bounds all  ()const { return interval_bounds(_bits & _all  ); }
     interval_bounds left ()const { return interval_bounds(_bits & _left ); }
     interval_bounds right()const { return interval_bounds(_bits & _right); }
-    interval_bounds reverse_left ()const { return interval_bounds((~_bits>>1) & _right); }
-    interval_bounds reverse_right()const { return interval_bounds((~_bits<<1) & _left ); }
+    interval_bounds reverse_left ()const { return interval_bounds((bound_type(~_bits)>>1) & _right); }
+    interval_bounds reverse_right()const { return interval_bounds((bound_type(~_bits)<<1) & _left ); }
 
     bound_type bits()const{ return _bits; }
 
diff --git a/boost/icl/type_traits/predicate.hpp b/boost/icl/type_traits/predicate.hpp
index 405c643..7d7de37 100644
--- a/boost/icl/type_traits/predicate.hpp
+++ b/boost/icl/type_traits/predicate.hpp
@@ -8,8 +8,6 @@ Copyright (c) 2010-2010: Joachim Faulhaber
 #ifndef BOOST_ICL_TYPE_TRAITS_PREDICATE_HPP_JOFA_101102
 #define BOOST_ICL_TYPE_TRAITS_PREDICATE_HPP_JOFA_101102
 
-#include <functional>
-
 namespace boost{namespace icl
 {
     // naming convention
@@ -20,7 +18,12 @@ namespace boost{namespace icl
     // Unary predicates
 
     template <class Type>
-    class property : public std::unary_function<Type,bool>{};
+    class property
+    {
+    public:
+        typedef Type argument_type;
+        typedef bool result_type;
+    };
 
     template <class Type>
     class member_property : public property<Type>
@@ -35,7 +38,13 @@ namespace boost{namespace icl
     // Binary predicates: relations
 
     template <class LeftT, class RightT>
-    class relation : public std::binary_function<LeftT,RightT,bool>{};
+    class relation
+    {
+    public:
+        typedef LeftT first_argument_type;
+        typedef RightT second_argument_type;
+        typedef bool result_type;
+    };
 
 
 }} // namespace icl boost
diff --git a/boost/icl/type_traits/type_to_string.hpp b/boost/icl/type_traits/type_to_string.hpp
index 80c473a..994711b 100644
--- a/boost/icl/type_traits/type_to_string.hpp
+++ b/boost/icl/type_traits/type_to_string.hpp
@@ -43,7 +43,6 @@ namespace boost{ namespace icl
 
     template<>inline std::string type_to_string<float>::apply() { return "flt"; }
     template<>inline std::string type_to_string<double>::apply() { return "dbl"; }
-    template<>inline std::string type_to_string<std::string>::apply() { return "string"; }
 
     //-------------------------------------------------------------------------
     template<template<class> class Templ>
@@ -78,6 +77,13 @@ namespace boost{ namespace icl
         }
     };
 
+    // ---------------------------------------------------------------------------
+    template<>
+    struct type_to_string<std::string>
+    {
+        static std::string apply() { return "string"; }
+    };
+
 }} // namespace boost icl
 
 #endif
diff --git a/boost/integer/common_factor_ct.hpp b/boost/integer/common_factor_ct.hpp
new file mode 100644
index 0000000..0671d16
--- /dev/null
+++ b/boost/integer/common_factor_ct.hpp
@@ -0,0 +1,102 @@
+//  Boost common_factor_ct.hpp header file  ----------------------------------//
+
+//  (C) Copyright Daryle Walker and Stephen Cleary 2001-2002.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+//  See http://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_CT_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_CT_HPP
+
+#include <boost/integer_fwd.hpp>  // self include
+#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
+
+namespace boost
+{
+namespace integer
+{
+
+//  Implementation details  --------------------------------------------------//
+
+namespace detail
+{
+    // Build GCD with Euclid's recursive algorithm
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd_helper_t
+    {
+    private:
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 );
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 );
+
+        #ifndef __BORLANDC__
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value)
+        #else
+        typedef static_gcd_helper_t  self_type;
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value)  (self_type:: Value )
+        #endif
+
+        typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),
+         BOOST_DETAIL_GCD_HELPER_VAL(new_value2) >  next_step_type;
+
+        #undef BOOST_DETAIL_GCD_HELPER_VAL
+
+    public:
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value );
+    };
+
+    // Non-recursive case
+    template < static_gcd_type Value1 >
+    struct static_gcd_helper_t< Value1, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 );
+    };
+
+    // Build the LCM from the GCD
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm_helper_t
+    {
+        typedef static_gcd_helper_t<Value1, Value2>  gcd_type;
+
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value
+         * Value2 );
+    };
+
+    // Special case for zero-GCD values
+    template < >
+    struct static_lcm_helper_t< 0UL, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL );
+    };
+
+}  // namespace detail
+
+
+//  Compile-time greatest common divisor evaluator class declaration  --------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_gcd
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_gcd_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_gcd
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_gcd< Value1, Value2 >::value;
+#endif
+
+//  Compile-time least common multiple evaluator class declaration  ----------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_lcm
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_lcm_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_lcm
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_lcm< Value1, Value2 >::value;
+#endif
+
+}  // namespace integer
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_CT_HPP
diff --git a/boost/integer/static_log2.hpp b/boost/integer/static_log2.hpp
new file mode 100644
index 0000000..56c7a00
--- /dev/null
+++ b/boost/integer/static_log2.hpp
@@ -0,0 +1,127 @@
+// -------------- Boost static_log2.hpp header file  ----------------------- //
+//
+//                 Copyright (C) 2001 Daryle Walker.
+//                 Copyright (C) 2003 Vesa Karvonen.
+//                 Copyright (C) 2003 Gennaro Prota.
+//
+//     Distributed under the Boost Software License, Version 1.0.
+//        (See accompanying file LICENSE_1_0.txt or copy at
+//              http://www.boost.org/LICENSE_1_0.txt)
+//
+//         ---------------------------------------------------
+//       See http://www.boost.org/libs/integer for documentation.
+// ------------------------------------------------------------------------- //
+
+
+#ifndef BOOST_INTEGER_STATIC_LOG2_HPP
+#define BOOST_INTEGER_STATIC_LOG2_HPP
+
+#include "boost/integer_fwd.hpp" // for boost::intmax_t
+
+namespace boost {
+
+ namespace detail {
+
+     namespace static_log2_impl {
+
+     // choose_initial_n<>
+     //
+     // Recursively doubles its integer argument, until it
+     // becomes >= of the "width" (C99, 6.2.6.2p4) of
+     // static_log2_argument_type.
+     //
+     // Used to get the maximum power of two less then the width.
+     //
+     // Example: if on your platform argument_type has 48 value
+     //          bits it yields n=32.
+     //
+     // It's easy to prove that, starting from such a value
+     // of n, the core algorithm works correctly for any width
+     // of static_log2_argument_type and that recursion always
+     // terminates with x = 1 and n = 0 (see the algorithm's
+     // invariant).
+
+     typedef boost::static_log2_argument_type argument_type;
+     typedef boost::static_log2_result_type result_type;
+
+     template <result_type n>
+     struct choose_initial_n {
+
+         BOOST_STATIC_CONSTANT(bool, c = (argument_type(1) << n << n) != 0);
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = !c*n + choose_initial_n<2*c*n>::value
+         );
+
+     };
+
+     template <>
+     struct choose_initial_n<0> {
+         BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+
+
+     // start computing from n_zero - must be a power of two
+     const result_type n_zero = 16;
+     const result_type initial_n = choose_initial_n<n_zero>::value;
+
+     // static_log2_impl<>
+     //
+     // * Invariant:
+     //                 2n
+     //  1 <= x && x < 2    at the start of each recursion
+     //                     (see also choose_initial_n<>)
+     //
+     // * Type requirements:
+     //
+     //   argument_type maybe any unsigned type with at least n_zero + 1
+     //   value bits. (Note: If larger types will be standardized -e.g.
+     //   unsigned long long- then the argument_type typedef can be
+     //   changed without affecting the rest of the code.)
+     //
+
+     template <argument_type x, result_type n = initial_n>
+     struct static_log2_impl {
+
+         BOOST_STATIC_CONSTANT(bool, c = (x >> n) > 0); // x >= 2**n ?
+         BOOST_STATIC_CONSTANT(
+             result_type,
+             value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)
+         );
+
+     };
+
+     template <>
+     struct static_log2_impl<1, 0> {
+        BOOST_STATIC_CONSTANT(result_type, value = 0);
+     };
+
+     }
+ } // detail
+
+
+
+ // --------------------------------------
+ // static_log2<x>
+ // ----------------------------------------
+
+ template <static_log2_argument_type x>
+ struct static_log2 {
+
+     BOOST_STATIC_CONSTANT(
+         static_log2_result_type,
+         value = detail::static_log2_impl::static_log2_impl<x>::value
+     );
+
+ };
+
+
+ template <>
+ struct static_log2<0> { };
+
+}
+
+
+
+#endif // include guard
diff --git a/boost/integer_fwd.hpp b/boost/integer_fwd.hpp
index 10577ae..18519dd 100644
--- a/boost/integer_fwd.hpp
+++ b/boost/integer_fwd.hpp
@@ -159,6 +159,8 @@ template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Valu
     struct static_unsigned_max;
 
 
+namespace integer
+{
 //  From <boost/integer/common_factor_ct.hpp>
 
 #ifdef BOOST_NO_INTEGRAL_INT64_T
@@ -180,6 +182,7 @@ template < typename IntegerType >
 template < typename IntegerType >
     class lcm_evaluator;
 
+} // namespace integer
 
 }  // namespace boost
 
diff --git a/boost/intrusive/bstree.hpp b/boost/intrusive/bstree.hpp
index 1eeab55..410eedf 100644
--- a/boost/intrusive/bstree.hpp
+++ b/boost/intrusive/bstree.hpp
@@ -255,7 +255,8 @@ struct get_key_of_value<void, T>
 template<class ValuePtr, class VoidOrKeyOfValue, class VoidOrKeyComp>
 struct bst_key_types
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef typename get_key_of_value
       < VoidOrKeyOfValue, value_type>::type           key_of_value;
    typedef typename key_of_value::type                key_type;
@@ -724,15 +725,22 @@ class bstree_impl
          this->insert_equal(b, e);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Constructs a container moving resources from another container.
+   //!   Internal comparison object and value traits are move constructed and
+   //!   nodes belonging to x (except the node representing the "end") are linked to *this.
    //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: If value_traits::node_traits::node's
+   //!   move constructor throws (this does not happen with predefined Boost.Intrusive hooks)
+   //!   or the move constructor of the comparison objet throws.
    bstree_impl(BOOST_RV_REF(bstree_impl) x)
       : data_type(::boost::move(x.comp()), ::boost::move(x.get_value_traits()))
    {
       this->swap(x);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Equivalent to swap
    //!
    BOOST_INTRUSIVE_FORCEINLINE bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x)
    {  this->swap(x); return *this;  }
diff --git a/boost/intrusive/detail/default_header_holder.hpp b/boost/intrusive/detail/default_header_holder.hpp
index 288f8a0..ba561b5 100644
--- a/boost/intrusive/detail/default_header_holder.hpp
+++ b/boost/intrusive/detail/default_header_holder.hpp
@@ -23,7 +23,7 @@
 
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -48,7 +48,7 @@ struct default_header_holder : public NodeTraits::node
 
    // (unsafe) downcast used to implement container-from-iterator
    BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
-   { return static_cast< default_header_holder* >(boost::intrusive::detail::to_raw_pointer(p)); }
+   { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 
 // type function producing the header node holder
diff --git a/boost/intrusive/detail/ebo_functor_holder.hpp b/boost/intrusive/detail/ebo_functor_holder.hpp
index 31b2f81..27415c1 100644
--- a/boost/intrusive/detail/ebo_functor_holder.hpp
+++ b/boost/intrusive/detail/ebo_functor_holder.hpp
@@ -35,7 +35,7 @@ namespace detail {
 #define BOOST_INTRUSIVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 
diff --git a/boost/intrusive/detail/hook_traits.hpp b/boost/intrusive/detail/hook_traits.hpp
index 2a16061..7a6f206 100644
--- a/boost/intrusive/detail/hook_traits.hpp
+++ b/boost/intrusive/detail/hook_traits.hpp
@@ -26,7 +26,7 @@
 #include <boost/intrusive/detail/parent_from_member.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 
 namespace boost {
@@ -128,14 +128,14 @@ struct mhtraits
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
    BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 };
 
@@ -161,10 +161,10 @@ struct fhtraits
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
    static node_ptr to_node_ptr(reference value)
-   {  return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static const_node_ptr to_node_ptr(const_reference value)
-   {  return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static pointer to_value_ptr(const node_ptr & n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
diff --git a/boost/intrusive/detail/iterator.hpp b/boost/intrusive/detail/iterator.hpp
index 2ae6abb..c25be43 100644
--- a/boost/intrusive/detail/iterator.hpp
+++ b/boost/intrusive/detail/iterator.hpp
@@ -27,6 +27,24 @@
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/meta_utils_core.hpp>
 
+namespace boost{
+namespace iterators{
+
+struct incrementable_traversal_tag;
+struct single_pass_traversal_tag;
+struct forward_traversal_tag;
+struct bidirectional_traversal_tag;
+struct random_access_traversal_tag;
+
+namespace detail{
+
+template <class Category, class Traversal>
+struct iterator_category_with_traversal;
+
+} //namespace boost{
+} //namespace iterators{
+} //namespace detail{
+
 namespace boost {
 namespace intrusive {
 
@@ -45,6 +63,28 @@ struct iterator
    typedef Reference    reference;
 };
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_boost_iterator
+////////////////////////////////////////
+template<class I>
+struct is_boost_iterator
+{
+   static const bool value = false;
+};
+
+template<class Category, class Traversal>
+struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
+{
+   static const bool value = true;
+};
+
+template<class I, class R = void>
+struct iterator_enable_if_boost_iterator
+   : ::boost::move_detail::enable_if_c
+      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
+      , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag
 ////////////////////////////////////////
@@ -68,6 +108,23 @@ struct iterator_disable_if_tag
          , R>
 {};
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_tag
+////////////////////////////////////////
+template<class I, class Tag, class Tag2, class R = void>
+struct iterator_enable_if_convertible_tag
+   : ::boost::move_detail::enable_if_c
+      < ::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag
+         >::value &&
+        !::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag2
+         >::value
+         , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag_difference_type
 ////////////////////////////////////////
@@ -84,8 +141,9 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 //    advance
 ////////////////////
+
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    while(n--)
@@ -101,7 +159,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 }
 
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    for (; 0 < n; --n)
@@ -117,6 +175,54 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
    it += n;
 }
 
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   for (; 0 < n; --n)
+	   ++it;
+   for (; n < 0; ++n)
+	   --it;
+}
+
+class fake{};
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   it += n;
+}
+
 ////////////////////
 //    distance
 ////////////////////
diff --git a/boost/intrusive/detail/mpl.hpp b/boost/intrusive/detail/mpl.hpp
index 8d227a1..1523088 100644
--- a/boost/intrusive/detail/mpl.hpp
+++ b/boost/intrusive/detail/mpl.hpp
@@ -86,8 +86,8 @@ struct ls_zeros<1>
 
 // Infrastructure for providing a default type for T::TNAME if absent.
 #define BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(TNAME)     \
-   template <typename T, typename DefaultType>                    \
-   struct boost_intrusive_default_type_ ## TNAME                  \
+   template <typename T>                                          \
+   struct boost_intrusive_has_type_ ## TNAME                      \
    {                                                              \
       template <typename X>                                       \
       static char test(int, typename X::TNAME*);                  \
@@ -95,13 +95,18 @@ struct ls_zeros<1>
       template <typename X>                                       \
       static int test(...);                                       \
                                                                   \
-      struct DefaultWrap { typedef DefaultType TNAME; };          \
-                                                                  \
       static const bool value = (1 == sizeof(test<T>(0, 0)));     \
+   };                                                             \
+                                                                  \
+   template <typename T, typename DefaultType>                    \
+   struct boost_intrusive_default_type_ ## TNAME                  \
+   {                                                              \
+      struct DefaultWrap { typedef DefaultType TNAME; };          \
                                                                   \
       typedef typename                                            \
          ::boost::intrusive::detail::if_c                         \
-            <value, T, DefaultWrap>::type::TNAME type;            \
+            < boost_intrusive_has_type_ ## TNAME<T>::value        \
+            , T, DefaultWrap>::type::TNAME type;                  \
    };                                                             \
    //
 
@@ -110,6 +115,11 @@ struct ls_zeros<1>
          boost_intrusive_default_type_ ## TNAME< T, TIMPL >::type                            \
 //
 
+#define BOOST_INTRUSIVE_HAS_TYPE(INSTANTIATION_NS_PREFIX, T, TNAME)  \
+      INSTANTIATION_NS_PREFIX                                        \
+         boost_intrusive_has_type_ ## TNAME< T >::value              \
+//
+
 #define BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(TNAME)\
    template <typename T, typename DefaultType>                    \
    struct boost_intrusive_eval_default_type_ ## TNAME             \
diff --git a/boost/intrusive/detail/tree_value_compare.hpp b/boost/intrusive/detail/tree_value_compare.hpp
index c8f596f..f6dd01d 100644
--- a/boost/intrusive/detail/tree_value_compare.hpp
+++ b/boost/intrusive/detail/tree_value_compare.hpp
@@ -37,7 +37,8 @@ struct disable_if_smartref_to
       || detail::is_same
             <From, typename pointer_traits
                      < typename pointer_rebind
-                           <ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
+                           < ValuePtr
+                           , const typename boost::movelib::pointer_element<ValuePtr>::type>::type>
                   ::reference>::value
       >
 {};
@@ -45,11 +46,13 @@ struct disable_if_smartref_to
 //This function object takes a KeyCompare function object
 //and compares values that contains keys using KeyOfValue
 template< class ValuePtr, class KeyCompare, class KeyOfValue
-        , bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
+        , bool = boost::intrusive::detail::is_same
+   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
 struct tree_value_compare
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
@@ -114,7 +117,8 @@ template<class ValuePtr, class KeyCompare, class KeyOfValue>
 struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
diff --git a/boost/intrusive/pointer_traits.hpp b/boost/intrusive/pointer_traits.hpp
index 5baf5e8..4216c7e 100644
--- a/boost/intrusive/pointer_traits.hpp
+++ b/boost/intrusive/pointer_traits.hpp
@@ -20,7 +20,7 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
-#include <boost/intrusive/detail/pointer_element.hpp>
+#include <boost/move/detail/pointer_element.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <cstddef>
 
@@ -97,7 +97,7 @@ struct pointer_traits
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT
          ( boost::intrusive::detail::, Ptr, element_type
-         , boost::intrusive::detail::first_param<Ptr>)                        element_type;
+         , boost::movelib::detail::first_param<Ptr>)                          element_type;
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
          (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
diff --git a/boost/intrusive/slist.hpp b/boost/intrusive/slist.hpp
index f34350d..1f7ace1 100644
--- a/boost/intrusive/slist.hpp
+++ b/boost/intrusive/slist.hpp
@@ -338,8 +338,15 @@ class slist_impl
       this->insert_after(this->cbefore_begin(), b, e);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Constructs a container moving resources from another container.
+   //!   Internal value traits are move constructed and
+   //!   nodes belonging to x (except the node representing the "end") are linked to *this.
    //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: If value_traits::node_traits::node's
+   //!   move constructor throws (this does not happen with predefined Boost.Intrusive hooks)
+   //!   or the move constructor of value traits throws.
    slist_impl(BOOST_RV_REF(slist_impl) x)
       : data_(::boost::move(x.priv_value_traits()))
    {
@@ -348,7 +355,7 @@ class slist_impl
       this->swap(x);
    }
 
-   //! <b>Effects</b>: to-do
+   //! <b>Effects</b>: Equivalent to swap
    //!
    slist_impl& operator=(BOOST_RV_REF(slist_impl) x)
    {  this->swap(x); return *this;  }
diff --git a/boost/iterator/advance.hpp b/boost/iterator/advance.hpp
new file mode 100644
index 0000000..6f81cdb
--- /dev/null
+++ b/boost/iterator/advance.hpp
@@ -0,0 +1,84 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_ITERATOR_ADVANCE_HPP
+#define BOOST_ITERATOR_ADVANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost {
+namespace iterators {
+
+    namespace detail {
+        template <typename InputIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            InputIterator& it
+          , Distance n
+          , incrementable_traversal_tag
+        )
+        {
+            while (n > 0) {
+                ++it;
+                --n;
+            }
+        }
+
+        template <typename BidirectionalIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            BidirectionalIterator& it
+          , Distance n
+          , bidirectional_traversal_tag
+        )
+        {
+            if (n >= 0) {
+                while (n > 0) {
+                    ++it;
+                    --n;
+                }
+            }
+            else {
+                while (n < 0) {
+                    --it;
+                    ++n;
+                }
+            }
+        }
+
+        template <typename RandomAccessIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            RandomAccessIterator& it
+          , Distance n
+          , random_access_traversal_tag
+        )
+        {
+            it += n;
+        }
+    }
+
+    namespace advance_adl_barrier {
+        template <typename InputIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance(InputIterator& it, Distance n)
+        {
+            detail::advance_impl(
+                it, n, typename iterator_traversal<InputIterator>::type()
+            );
+        }
+    }
+
+    using namespace advance_adl_barrier;
+
+} // namespace iterators
+
+using iterators::advance;
+
+} // namespace boost
+
+#endif
diff --git a/boost/iterator/iterator_adaptor.hpp b/boost/iterator/iterator_adaptor.hpp
index 87cfd05..f803fc6 100644
--- a/boost/iterator/iterator_adaptor.hpp
+++ b/boost/iterator/iterator_adaptor.hpp
@@ -8,8 +8,6 @@
 #define BOOST_ITERATOR_ADAPTOR_23022003THW_HPP
 
 #include <boost/static_assert.hpp>
-#include <boost/iterator.hpp>
-#include <boost/detail/iterator.hpp>
 
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_facade.hpp>
diff --git a/boost/iterator/iterator_categories.hpp b/boost/iterator/iterator_categories.hpp
index 71202c9..baf805a 100644
--- a/boost/iterator/iterator_categories.hpp
+++ b/boost/iterator/iterator_categories.hpp
@@ -7,7 +7,6 @@
 # define BOOST_ITERATOR_CATEGORIES_HPP
 
 # include <boost/config.hpp>
-# include <boost/detail/iterator.hpp>
 # include <boost/iterator/detail/config_def.hpp>
 
 # include <boost/detail/workaround.hpp>
@@ -21,6 +20,8 @@
 
 # include <boost/static_assert.hpp>
 
+#include <iterator>
+
 namespace boost {
 namespace iterators {
 
@@ -116,7 +117,7 @@ struct iterator_category_to_traversal
 template <class Iterator = mpl::_1>
 struct iterator_traversal
   : iterator_category_to_traversal<
-        typename boost::detail::iterator_traits<Iterator>::iterator_category
+        typename std::iterator_traits<Iterator>::iterator_category
     >
 {};
 
diff --git a/boost/iterator/iterator_concepts.hpp b/boost/iterator/iterator_concepts.hpp
index 1a9f7d6..415cc49 100644
--- a/boost/iterator/iterator_concepts.hpp
+++ b/boost/iterator/iterator_concepts.hpp
@@ -9,9 +9,6 @@
 #include <boost/concept_check.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 
-// Use boost::detail::iterator_traits to work around some MSVC/Dinkumware problems.
-#include <boost/detail/iterator.hpp>
-
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_integral.hpp>
 
@@ -27,6 +24,7 @@
 #include <boost/config.hpp>
 
 #include <algorithm>
+#include <iterator>
 
 #include <boost/concept/detail/concept_def.hpp>
 
@@ -44,8 +42,8 @@ namespace boost_concepts
     , boost::CopyConstructible<Iterator>
 
   {
-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type value_type;
-      typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference reference;
+      typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type value_type;
+      typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference reference;
 
       BOOST_CONCEPT_USAGE(ReadableIterator)
       {
@@ -59,7 +57,7 @@ namespace boost_concepts
 
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
   >
   struct WritableIterator
     : boost::CopyConstructible<Iterator>
@@ -75,7 +73,7 @@ namespace boost_concepts
 
   template <
       typename Iterator
-    , typename ValueType = BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::value_type
+    , typename ValueType = BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::value_type
   >
   struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};
 
@@ -92,7 +90,7 @@ namespace boost_concepts
 
   BOOST_concept(LvalueIterator,(Iterator))
   {
-      typedef typename boost::detail::iterator_traits<Iterator>::value_type value_type;
+      typedef typename std::iterator_traits<Iterator>::value_type value_type;
 
       BOOST_CONCEPT_USAGE(LvalueIterator)
       {
@@ -144,7 +142,7 @@ namespace boost_concepts
     : SinglePassIterator<Iterator>
     , boost::DefaultConstructible<Iterator>
   {
-      typedef typename boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+      typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
 
       BOOST_MPL_ASSERT((boost::is_integral<difference_type>));
       BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
@@ -221,7 +219,7 @@ namespace boost_concepts
         boost::random_access_traversal_tag, boost::random_access_traversal_tag)
     {
         bool b;
-        typename boost::detail::iterator_traits<Iterator2>::difference_type n;
+        typename std::iterator_traits<Iterator2>::difference_type n;
         b = i1 <  i2;
         b = i1 <= i2;
         b = i1 >  i2;
diff --git a/boost/iterator/iterator_facade.hpp b/boost/iterator/iterator_facade.hpp
index 7b11d0a..225c53a 100644
--- a/boost/iterator/iterator_facade.hpp
+++ b/boost/iterator/iterator_facade.hpp
@@ -8,7 +8,6 @@
 #define BOOST_ITERATOR_FACADE_23022003THW_HPP
 
 #include <boost/config.hpp>
-#include <boost/iterator.hpp>
 #include <boost/iterator/interoperable.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_categories.hpp>
@@ -37,6 +36,8 @@
 #include <boost/mpl/apply.hpp>
 #include <boost/mpl/identity.hpp>
 
+#include <cstddef>
+
 #include <boost/iterator/detail/config_def.hpp> // this goes last
 
 namespace boost {
diff --git a/boost/iterator/iterator_traits.hpp b/boost/iterator/iterator_traits.hpp
index 1a5f1e0..6582a68 100644
--- a/boost/iterator/iterator_traits.hpp
+++ b/boost/iterator/iterator_traits.hpp
@@ -5,9 +5,10 @@
 #ifndef ITERATOR_TRAITS_DWA200347_HPP
 # define ITERATOR_TRAITS_DWA200347_HPP
 
-# include <boost/detail/iterator.hpp>
 # include <boost/detail/workaround.hpp>
 
+#include <iterator>
+
 namespace boost {
 namespace iterators {
 
@@ -19,32 +20,32 @@ namespace iterators {
 template <class Iterator>
 struct iterator_value
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
+    typedef typename std::iterator_traits<Iterator>::value_type type;
 };
 
 template <class Iterator>
 struct iterator_reference
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+    typedef typename std::iterator_traits<Iterator>::reference type;
 };
 
 
 template <class Iterator>
 struct iterator_pointer
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
+    typedef typename std::iterator_traits<Iterator>::pointer type;
 };
 
 template <class Iterator>
 struct iterator_difference
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
+    typedef typename std::iterator_traits<Iterator>::difference_type type;
 };
 
 template <class Iterator>
 struct iterator_category
 {
-    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
+    typedef typename std::iterator_traits<Iterator>::iterator_category type;
 };
 
 } // namespace iterators
diff --git a/boost/iterator/reverse_iterator.hpp b/boost/iterator/reverse_iterator.hpp
index 3bef39e..03b7925 100644
--- a/boost/iterator/reverse_iterator.hpp
+++ b/boost/iterator/reverse_iterator.hpp
@@ -7,8 +7,6 @@
 #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 
-#include <boost/next_prior.hpp>
-#include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
 namespace boost {
@@ -40,14 +38,19 @@ namespace iterators {
       {}
 
    private:
-      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+      typename super_t::reference dereference() const
+      {
+          Iterator it = this->base_reference();
+          --it;
+          return *it;
+      }
 
       void increment() { --this->base_reference(); }
       void decrement() { ++this->base_reference(); }
 
       void advance(typename super_t::difference_type n)
       {
-          this->base_reference() += -n;
+          this->base_reference() -= n;
       }
 
       template <class OtherIterator>
diff --git a/boost/math/common_factor_ct.hpp b/boost/math/common_factor_ct.hpp
index bf58b94..3ca0905 100644
--- a/boost/math/common_factor_ct.hpp
+++ b/boost/math/common_factor_ct.hpp
@@ -1,6 +1,6 @@
 //  Boost common_factor_ct.hpp header file  ----------------------------------//
 
-//  (C) Copyright Daryle Walker and Stephen Cleary 2001-2002.
+//  (C) Copyright John Maddock 2017.
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -10,85 +10,16 @@
 #ifndef BOOST_MATH_COMMON_FACTOR_CT_HPP
 #define BOOST_MATH_COMMON_FACTOR_CT_HPP
 
-#include <boost/math_fwd.hpp>  // self include
-#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
-#include <boost/mpl/integral_c.hpp>
+#include <boost/integer/common_factor_ct.hpp>
 
 namespace boost
 {
 namespace math
 {
 
-//  Implementation details  --------------------------------------------------//
-
-namespace detail
-{
-    // Build GCD with Euclid's recursive algorithm
-    template < static_gcd_type Value1, static_gcd_type Value2 >
-    struct static_gcd_helper_t
-    {
-    private:
-        BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 );
-        BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 );
-
-        #ifndef __BORLANDC__
-        #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value)
-        #else
-        typedef static_gcd_helper_t  self_type;
-        #define BOOST_DETAIL_GCD_HELPER_VAL(Value)  (self_type:: Value )
-        #endif
-
-        typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),
-         BOOST_DETAIL_GCD_HELPER_VAL(new_value2) >  next_step_type;
-
-        #undef BOOST_DETAIL_GCD_HELPER_VAL
-
-    public:
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value );
-    };
-
-    // Non-recursive case
-    template < static_gcd_type Value1 >
-    struct static_gcd_helper_t< Value1, 0UL >
-    {
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 );
-    };
-
-    // Build the LCM from the GCD
-    template < static_gcd_type Value1, static_gcd_type Value2 >
-    struct static_lcm_helper_t
-    {
-        typedef static_gcd_helper_t<Value1, Value2>  gcd_type;
-
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value
-         * Value2 );
-    };
-
-    // Special case for zero-GCD values
-    template < >
-    struct static_lcm_helper_t< 0UL, 0UL >
-    {
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL );
-    };
-
-}  // namespace detail
-
-
-//  Compile-time greatest common divisor evaluator class declaration  --------//
-
-template < static_gcd_type Value1, static_gcd_type Value2 >
-struct static_gcd : public mpl::integral_c<static_gcd_type, (detail::static_gcd_helper_t<Value1, Value2>::value) >
-{
-};  // boost::math::static_gcd
-
-
-//  Compile-time least common multiple evaluator class declaration  ----------//
-
-template < static_gcd_type Value1, static_gcd_type Value2 >
-struct static_lcm : public mpl::integral_c<static_gcd_type, (detail::static_lcm_helper_t<Value1, Value2>::value) >
-{
-};  // boost::math::static_lcm
-
+   using boost::integer::static_gcd;
+   using boost::integer::static_lcm;
+   using boost::integer::static_gcd_type;
 
 }  // namespace math
 }  // namespace boost
diff --git a/boost/move/algo/adaptive_merge.hpp b/boost/move/algo/adaptive_merge.hpp
new file mode 100644
index 0000000..0233b23
--- /dev/null
+++ b/boost/move/algo/adaptive_merge.hpp
@@ -0,0 +1,67 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_ADAPTIVE_MERGE_HPP
+#define BOOST_MOVE_ADAPTIVE_MERGE_HPP
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/algo/detail/adaptive_sort_merge.hpp>
+
+namespace boost {
+namespace movelib {
+
+//! <b>Effects</b>: Merges two consecutive sorted ranges [first, middle) and [middle, last)
+//!   into one sorted range [first, last) according to the given comparison function comp.
+//!   The algorithm is stable (if there are equivalent elements in the original two ranges,
+//!   the elements from the first range (preserving their original order) precede the elements
+//!   from the second range (preserving their original order).
+//!
+//! <b>Requires</b>:
+//!   - RandIt must meet the requirements of ValueSwappable and RandomAccessIterator.
+//!   - The type of dereferenced RandIt must meet the requirements of MoveAssignable and MoveConstructible.
+//!
+//! <b>Parameters</b>:
+//!   - first: the beginning of the first sorted range. 
+//!   - middle: the end of the first sorted range and the beginning of the second
+//!   - last: the end of the second sorted range
+//!   - comp: comparison function object which returns true if the first argument is is ordered before the second.
+//!   - uninitialized, uninitialized_len: raw storage starting on "uninitialized", able to hold "uninitialized_len"
+//!      elements of type iterator_traits<RandIt>::value_type. Maximum performance is achieved when uninitialized_len
+//!      is min(std::distance(first, middle), std::distance(middle, last)).
+//!
+//! <b>Throws</b>: If comp throws or the move constructor, move assignment or swap of the type
+//!   of dereferenced RandIt throws.
+//!
+//! <b>Complexity</b>: Always K x O(N) comparisons and move assignments/constructors/swaps.
+//!   Constant factor for comparisons and data movement is minimized when uninitialized_len
+//!   is min(std::distance(first, middle), std::distance(middle, last)).
+//!   Pretty good enough performance is achieved when uninitialized_len is
+//!   ceil(sqrt(std::distance(first, last)))*2.
+//!
+//! <b>Caution</b>: Experimental implementation, not production-ready.
+template<class RandIt, class Compare>
+void adaptive_merge( RandIt first, RandIt middle, RandIt last, Compare comp
+                , typename iterator_traits<RandIt>::value_type* uninitialized = 0
+                , std::size_t uninitialized_len = 0)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+
+   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type> xbuf(uninitialized, uninitialized_len);
+   ::boost::movelib::detail_adaptive::adaptive_merge_impl(first, size_type(middle - first), size_type(last - middle), comp, xbuf);
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif   //#define BOOST_MOVE_ADAPTIVE_MERGE_HPP
diff --git a/boost/move/algo/adaptive_sort.hpp b/boost/move/algo/adaptive_sort.hpp
new file mode 100644
index 0000000..c96ab2d
--- /dev/null
+++ b/boost/move/algo/adaptive_sort.hpp
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_ADAPTIVE_SORT_HPP
+#define BOOST_MOVE_ADAPTIVE_SORT_HPP
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/algo/detail/adaptive_sort_merge.hpp>
+
+namespace boost {
+namespace movelib {
+
+//! <b>Effects</b>: Sorts the elements in the range [first, last) in ascending order according
+//!   to comparison functor "comp". The sort is stable (order of equal elements
+//!   is guaranteed to be preserved). Performance is improved if additional raw storage is
+//!   provided.
+//!
+//! <b>Requires</b>:
+//!   - RandIt must meet the requirements of ValueSwappable and RandomAccessIterator.
+//!   - The type of dereferenced RandIt must meet the requirements of MoveAssignable and MoveConstructible.
+//!
+//! <b>Parameters</b>:
+//!   - first, last: the range of elements to sort
+//!   - comp: comparison function object which returns true if the first argument is is ordered before the second.
+//!   - uninitialized, uninitialized_len: raw storage starting on "uninitialized", able to hold "uninitialized_len"
+//!      elements of type iterator_traits<RandIt>::value_type. Maximum performance is achieved when uninitialized_len
+//!      is ceil(std::distance(first, last)/2).
+//!
+//! <b>Throws</b>: If comp throws or the move constructor, move assignment or swap of the type
+//!   of dereferenced RandIt throws.
+//!
+//! <b>Complexity</b>: Always K x O(Nxlog(N)) comparisons and move assignments/constructors/swaps.
+//!   Comparisons are close to minimum even with no additional memory. Constant factor for data movement is minimized
+//!   when uninitialized_len is ceil(std::distance(first, last)/2). Pretty good enough performance is achieved when
+//!   ceil(sqrt(std::distance(first, last)))*2.
+//!
+//! <b>Caution</b>: Experimental implementation, not production-ready.
+template<class RandIt, class RandRawIt, class Compare>
+void adaptive_sort( RandIt first, RandIt last, Compare comp
+               , RandRawIt uninitialized
+               , std::size_t uninitialized_len)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+
+   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
+   ::boost::movelib::detail_adaptive::adaptive_sort_impl(first, size_type(last - first), comp, xbuf);
+}
+
+template<class RandIt, class Compare>
+void adaptive_sort( RandIt first, RandIt last, Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+   adaptive_sort(first, last, comp, (value_type*)0, 0u);
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif   //#define BOOST_MOVE_ADAPTIVE_SORT_HPP
diff --git a/boost/move/algo/detail/adaptive_sort_merge.hpp b/boost/move/algo/detail/adaptive_sort_merge.hpp
new file mode 100644
index 0000000..5085100
--- /dev/null
+++ b/boost/move/algo/detail/adaptive_sort_merge.hpp
@@ -0,0 +1,2470 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// Stable sorting that works in O(N*log(N)) worst time
+// and uses O(1) extra memory
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// The main idea of the adaptive_sort algorithm was developed by Andrey Astrelin
+// and explained in the article from the russian collaborative blog
+// Habrahabr (http://habrahabr.ru/post/205290/). The algorithm is based on
+// ideas from B-C. Huang and M. A. Langston explained in their article
+// "Fast Stable Merging and Sorting in Constant Extra Space (1989-1992)"
+// (http://comjnl.oxfordjournals.org/content/35/6/643.full.pdf).
+//
+// This implementation by Ion Gaztanaga uses previous ideas with additional changes:
+// 
+// - Use of GCD-based rotation.
+// - Non power of two buffer-sizes.
+// - Tries to find sqrt(len)*2 unique keys, so that the merge sort
+//   phase can form up to sqrt(len)*4 segments if enough keys are found.
+// - The merge-sort phase can take advantage of external memory to
+//   save some additional combination steps.
+// - Combination phase: Blocks are selection sorted and merged in parallel.
+// - The combination phase is performed alternating merge to left and merge
+//   to right phases minimizing swaps due to internal buffer repositioning.
+// - When merging blocks special optimizations are made to avoid moving some
+//   elements twice.
+//
+// The adaptive_merge algorithm was developed by Ion Gaztanaga reusing some parts
+// from the sorting algorithm and implementing an additional block merge algorithm
+// without moving elements to left or right.
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_ADAPTIVE_SORT_MERGE_HPP
+#define BOOST_MOVE_ADAPTIVE_SORT_MERGE_HPP
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/reverse_iterator.hpp>
+#include <boost/move/algo/move.hpp>
+#include <boost/move/algo/detail/merge.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/detail/insertion_sort.hpp>
+#include <boost/move/algo/detail/merge_sort.hpp>
+#include <boost/move/algo/detail/merge.hpp>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+
+#ifndef BOOST_MOVE_ADAPTIVE_SORT_STATS_LEVEL
+   #define BOOST_MOVE_ADAPTIVE_SORT_STATS_LEVEL 1
+#endif
+
+#ifdef BOOST_MOVE_ADAPTIVE_SORT_STATS
+   #if BOOST_MOVE_ADAPTIVE_SORT_STATS_LEVEL == 2
+      #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1(STR, L) \
+         print_stats(STR, L)\
+      //
+
+      #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2(STR, L) \
+         print_stats(STR, L)\
+      //
+   #else
+      #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1(STR, L) \
+         print_stats(STR, L)\
+      //
+
+      #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2(STR, L)
+   #endif
+#else
+   #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1(STR, L)
+   #define BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2(STR, L)
+#endif
+
+#ifdef BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
+   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT  BOOST_ASSERT
+#else
+   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(L)
+#endif
+
+
+
+namespace boost {
+namespace movelib {
+
+namespace detail_adaptive {
+
+static const std::size_t AdaptiveSortInsertionSortThreshold = 16;
+//static const std::size_t AdaptiveSortInsertionSortThreshold = 4;
+BOOST_STATIC_ASSERT((AdaptiveSortInsertionSortThreshold&(AdaptiveSortInsertionSortThreshold-1)) == 0);
+
+#if defined BOOST_HAS_INTPTR_T
+   typedef ::boost::uintptr_t uintptr_t;
+#else
+   typedef std::size_t uintptr_t;
+#endif
+
+template<class T>
+const T &min_value(const T &a, const T &b)
+{
+   return a < b ? a : b;
+}
+
+template<class T>
+const T &max_value(const T &a, const T &b)
+{
+   return a > b ? a : b;
+}
+
+template<class ForwardIt, class Pred>
+bool is_sorted(ForwardIt const first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first, cur(first);
+      while (++next != last) {
+         if (pred(*next, *cur))
+            return false;
+         cur = next;
+      }
+   }
+   return true;
+}
+
+#if defined(BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS)
+
+bool is_sorted(::order_perf_type *first, ::order_perf_type *last, ::order_type_less)
+{
+   if (first != last) {
+      const order_perf_type *next = first, *cur(first);
+      while (++next != last) {
+         if (!(cur->key < next->key || (cur->key == next->key && cur->val < next->val)))
+            return false;
+         cur = next;
+      }
+   }
+   return true;
+}
+
+#endif   //BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
+
+template<class ForwardIt, class Pred>
+bool is_sorted_and_unique(ForwardIt first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first;
+      while (++next != last) {
+         if (!pred(*first, *next))
+            return false;
+         first = next;
+      }
+   }
+   return true;
+}
+
+template<class ForwardIt, class Pred, class V>
+typename iterator_traits<ForwardIt>::size_type
+   count_if_with(ForwardIt first, ForwardIt last, Pred pred, const V &v)
+{
+   typedef typename iterator_traits<ForwardIt>::size_type size_type;
+   size_type count = 0;
+   while(first != last) {
+      count += static_cast<size_type>(0 != pred(*first, v));
+      ++first;
+   }
+   return count;
+}
+
+template<class T, class RandRawIt = T*>
+class adaptive_xbuf
+{
+   adaptive_xbuf(const adaptive_xbuf &);
+   adaptive_xbuf & operator=(const adaptive_xbuf &);
+
+   public:
+   typedef RandRawIt iterator;
+
+   adaptive_xbuf()
+      : m_ptr(), m_size(0), m_capacity(0)
+   {}
+
+   adaptive_xbuf(RandRawIt raw_memory, std::size_t capacity)
+      : m_ptr(raw_memory), m_size(0), m_capacity(capacity)
+   {}
+
+   template<class RandIt>
+   void move_assign(RandIt first, std::size_t n)
+   {
+      if(n <= m_size){
+         boost::move(first, first+n, m_ptr);
+         std::size_t size = m_size;
+         while(size-- != n){
+            m_ptr[size].~T();
+         }
+         m_size = n;
+      }
+      else{
+         RandRawIt result = boost::move(first, first+m_size, m_ptr);
+         boost::uninitialized_move(first+m_size, first+n, result);
+         m_size = n;
+      }
+   }
+
+   template<class RandIt>
+   void push_back(RandIt first, std::size_t n)
+   {
+      BOOST_ASSERT(m_capacity - m_size >= n);
+      boost::uninitialized_move(first, first+n, m_ptr+m_size);
+      m_size += n;
+   }
+
+   template<class RandIt>
+   iterator add(RandIt it)
+   {
+      BOOST_ASSERT(m_size < m_capacity);
+      RandRawIt p_ret = m_ptr + m_size;
+      ::new(&*p_ret) T(::boost::move(*it));
+      ++m_size;
+      return p_ret;
+   }
+
+   template<class RandIt>
+   void insert(iterator pos, RandIt it)
+   {
+      if(pos == (m_ptr + m_size)){
+         this->add(it);
+      }
+      else{
+         this->add(m_ptr+m_size-1);
+         //m_size updated
+         boost::move_backward(pos, m_ptr+m_size-2, m_ptr+m_size-1);
+         *pos = boost::move(*it);
+      }
+   }
+
+   void set_size(std::size_t size)
+   {
+      m_size = size;
+   }
+
+   void shrink_to_fit(std::size_t const size)
+   {
+      if(m_size > size){
+         for(std::size_t szt_i = size; szt_i != m_size; ++szt_i){
+            m_ptr[szt_i].~T();
+         }
+         m_size = size;
+      }
+   }
+
+   void initialize_until(std::size_t const size, T &t)
+   {
+      BOOST_ASSERT(m_size < m_capacity);
+      if(m_size < size){
+         ::new((void*)&m_ptr[m_size]) T(::boost::move(t));
+         ++m_size;
+         for(; m_size != size; ++m_size){
+            ::new((void*)&m_ptr[m_size]) T(::boost::move(m_ptr[m_size-1]));
+         }
+         t = ::boost::move(m_ptr[m_size-1]);
+      }
+   }
+
+   private:
+   template<class RIt>
+   static bool is_raw_ptr(RIt)
+   {
+      return false;
+   }
+
+   static bool is_raw_ptr(T*)
+   {
+      return true;
+   }
+
+   public:
+   template<class U>
+   bool supports_aligned_trailing(std::size_t size, std::size_t trail_count) const
+   {
+      if(this->is_raw_ptr(this->data()) && m_capacity){
+         uintptr_t u_addr_sz = uintptr_t(&*(this->data()+size));
+         uintptr_t u_addr_cp = uintptr_t(&*(this->data()+this->capacity()));
+         u_addr_sz = ((u_addr_sz + sizeof(U)-1)/sizeof(U))*sizeof(U);
+         return (u_addr_cp >= u_addr_sz) && ((u_addr_cp - u_addr_sz)/sizeof(U) >= trail_count);
+      }
+      return false;
+   }
+
+   template<class U>
+   U *aligned_trailing() const
+   {
+      return this->aligned_trailing<U>(this->size());
+   }
+
+   template<class U>
+   U *aligned_trailing(std::size_t pos) const
+   {
+      uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
+      u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
+      return (U*)u_addr;
+   }
+
+   ~adaptive_xbuf()
+   {
+      this->clear();
+   }
+
+   std::size_t capacity() const
+   {  return m_capacity;   }
+
+   iterator data() const
+   {  return m_ptr;   }
+
+   iterator end() const
+   {  return m_ptr+m_size;   }
+
+   std::size_t size() const
+   {  return m_size;   }
+
+   bool empty() const
+   {  return !m_size;   }
+
+   void clear()
+   {
+      this->shrink_to_fit(0u);
+   }
+
+   private:
+   RandRawIt m_ptr;
+   std::size_t m_size;
+   std::size_t m_capacity;
+};
+
+template<class Iterator, class Op>
+class range_xbuf
+{
+   range_xbuf(const range_xbuf &);
+   range_xbuf & operator=(const range_xbuf &);
+
+   public:
+   typedef typename iterator_traits<Iterator>::size_type size_type;
+   typedef Iterator iterator;
+
+   range_xbuf(Iterator first, Iterator last)
+      : m_first(first), m_last(first), m_cap(last)
+   {}
+
+   template<class RandIt>
+   void move_assign(RandIt first, std::size_t n)
+   {
+      BOOST_ASSERT(size_type(n) <= size_type(m_cap-m_first));
+      m_last = Op()(forward_t(), first, first+n, m_first);
+   }
+
+   ~range_xbuf()
+   {}
+
+   std::size_t capacity() const
+   {  return m_cap-m_first;   }
+
+   Iterator data() const
+   {  return m_first;   }
+
+   Iterator end() const
+   {  return m_last;   }
+
+   std::size_t size() const
+   {  return m_last-m_first;   }
+
+   bool empty() const
+   {  return m_first == m_last;   }
+
+   void clear()
+   {
+      m_last = m_first;
+   }
+
+   template<class RandIt>
+   iterator add(RandIt it)
+   {
+      Iterator pos(m_last);
+      *pos = boost::move(*it);
+      ++m_last;
+      return pos;
+   }
+
+   void set_size(std::size_t size)
+   {
+      m_last  = m_first;
+      m_last += size;
+   }
+
+   private:
+   Iterator const m_first;
+   Iterator m_last;
+   Iterator const m_cap;
+};
+
+
+template<class RandIt, class Compare>
+RandIt skip_until_merge
+   ( RandIt first1, RandIt const last1
+   , const typename iterator_traits<RandIt>::value_type &next_key, Compare comp)
+{
+   while(first1 != last1 && !comp(next_key, *first1)){
+      ++first1;
+   }
+   return first1;
+}
+
+
+template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
+RandItB op_buffered_partial_merge_to_range1_and_buffer
+   ( RandIt1 first1, RandIt1 const last1
+   , RandIt2 &rfirst2, RandIt2 const last2
+   , RandItB &rfirstb, Compare comp, Op op )
+{
+   RandItB firstb = rfirstb;
+   RandItB lastb  = firstb;
+   RandIt2 first2 = rfirst2;
+
+   //Move to buffer while merging
+   //Three way moves need less moves when op is swap_op so use it
+   //when merging elements from range2 to the destination occupied by range1
+   if(first1 != last1 && first2 != last2){
+      op(three_way_t(), first2++, first1++, lastb++);
+
+      while(true){
+         if(first1 == last1){
+            break;
+         }
+         if(first2 == last2){
+            lastb = op(forward_t(), first1, last1, firstb);
+            break;
+         }
+         if (comp(*first2, *firstb)) {
+            op(three_way_t(), first2++, first1++, lastb++);
+         }
+         else {
+            op(three_way_t(), firstb++, first1++, lastb++);
+         }
+      }
+      rfirst2 = first2;
+      rfirstb = firstb;
+   }
+
+   return lastb;
+}
+
+template<class RandItKeys, class RandIt>
+void swap_and_update_key
+   ( RandItKeys const key_next
+   , RandItKeys const key_range2
+   , RandItKeys &key_mid
+   , RandIt const begin
+   , RandIt const end
+   , RandIt const with)
+{
+   if(begin != with){
+      ::boost::adl_move_swap_ranges(begin, end, with);
+      ::boost::adl_move_swap(*key_next, *key_range2);
+      if(key_next == key_mid){
+         key_mid = key_range2;
+      }
+      else if(key_mid == key_range2){
+         key_mid = key_next;
+      }
+   }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//                         MERGE BUFFERLESS
+//
+///////////////////////////////////////////////////////////////////////////////
+
+// [first1, last1) merge [last1,last2) -> [first1,last2)
+template<class RandIt, class Compare>
+RandIt partial_merge_bufferless_impl
+   (RandIt first1, RandIt last1, RandIt const last2, bool *const pis_range1_A, Compare comp)
+{
+   if(last1 == last2){
+      return first1;
+   }
+   bool const is_range1_A = *pis_range1_A;
+   if(first1 != last1 && comp(*last1, last1[-1])){
+      do{
+         RandIt const old_last1 = last1;
+         last1  = boost::movelib::lower_bound(last1, last2, *first1, comp);
+         first1 = rotate_gcd(first1, old_last1, last1);//old_last1 == last1 supported
+         if(last1 == last2){
+            return first1;
+         }
+         do{
+            ++first1;
+         } while(last1 != first1 && !comp(*last1, *first1) );
+      } while(first1 != last1);
+   }
+   *pis_range1_A = !is_range1_A;
+   return last1;
+}
+
+// [first1, last1) merge [last1,last2) -> [first1,last2)
+template<class RandIt, class Compare>
+RandIt partial_merge_bufferless
+   (RandIt first1, RandIt last1, RandIt const last2, bool *const pis_range1_A, Compare comp)
+{
+   return *pis_range1_A ? partial_merge_bufferless_impl(first1, last1, last2, pis_range1_A, comp)
+                        : partial_merge_bufferless_impl(first1, last1, last2, pis_range1_A, antistable<Compare>(comp));
+}
+
+template<class SizeType>
+static SizeType needed_keys_count(SizeType n_block_a, SizeType n_block_b)
+{
+   return n_block_a + n_block_b;
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+typename iterator_traits<RandIt>::size_type
+   find_next_block
+      ( RandItKeys key_first
+      , KeyCompare key_comp
+      , RandIt const first
+      , typename iterator_traits<RandIt>::size_type const l_block
+      , typename iterator_traits<RandIt>::size_type const ix_first_block
+      , typename iterator_traits<RandIt>::size_type const ix_last_block
+      , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type      size_type;
+   typedef typename iterator_traits<RandIt>::value_type     value_type;
+   typedef typename iterator_traits<RandItKeys>::value_type key_type;
+   BOOST_ASSERT(ix_first_block <= ix_last_block);
+   size_type ix_min_block = 0u;
+   for (size_type szt_i = ix_first_block; szt_i < ix_last_block; ++szt_i) {
+      const value_type &min_val = first[ix_min_block*l_block];
+      const value_type &cur_val = first[szt_i*l_block];
+      const key_type   &min_key = key_first[ix_min_block];
+      const key_type   &cur_key = key_first[szt_i];
+
+      bool const less_than_minimum = comp(cur_val, min_val) ||
+         (!comp(min_val, cur_val) && key_comp(cur_key, min_key));
+
+      if (less_than_minimum) {
+         ix_min_block = szt_i;
+      }
+   }
+   return ix_min_block;
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+void merge_blocks_bufferless
+   ( RandItKeys key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   //BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
+
+   size_type n_bef_irreg2 = 0;
+   bool l_irreg_pos_count = true;
+   RandItKeys key_mid(key_first + n_block_a);
+   RandIt const first_irr2 = first + l_irreg1 + (n_block_a+n_block_b)*l_block;
+   RandIt const last_irr2  = first_irr2 + l_irreg2;
+
+   {  //Selection sort blocks
+      size_type n_block_left = n_block_b + n_block_a;
+      RandItKeys key_range2(key_first);
+
+      size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+      size_type max_check = min_value(min_check+1, n_block_left);
+      for (RandIt f = first+l_irreg1; n_block_left; --n_block_left, ++key_range2, f += l_block, min_check -= min_check != 0, max_check -= max_check != 0) {
+         size_type const next_key_idx = find_next_block(key_range2, key_comp, f, l_block, min_check, max_check, comp);
+         RandItKeys const key_next(key_range2 + next_key_idx);
+         max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+
+         RandIt const first_min = f + next_key_idx*l_block;
+
+         //Check if irregular b block should go here.
+         //If so, break to the special code handling the irregular block
+         if (l_irreg_pos_count && l_irreg2 && comp(*first_irr2, *first_min)){
+            l_irreg_pos_count = false;
+         }
+         n_bef_irreg2 += l_irreg_pos_count;
+
+         swap_and_update_key(key_next, key_range2, key_mid, f, f + l_block, first_min);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(f, f+l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, first_min + l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((f == (first+l_irreg1)) || !comp(*f, *(f-l_block)));
+      }
+   }
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first+l_irreg1+n_bef_irreg2*l_block, first_irr2, comp));
+
+   RandIt first1 = first;
+   RandIt last1  = first+l_irreg1;
+   RandItKeys const key_end (key_first+n_bef_irreg2);
+   bool is_range1_A = true;
+
+   for( ; key_first != key_end; ++key_first){
+      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_first, *key_mid);
+      first1 = is_range1_A == is_range2_A
+         ? last1 : partial_merge_bufferless(first1, last1, last1 + l_block, &is_range1_A, comp);
+      last1 += l_block;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
+   }
+
+   merge_bufferless(is_range1_A ? first1 : last1, first_irr2, last_irr2, comp);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//                            BUFFERED MERGE
+//
+///////////////////////////////////////////////////////////////////////////////
+template<class RandIt, class Compare, class Op, class Buf>
+void op_buffered_merge
+      ( RandIt first, RandIt const middle, RandIt last
+      , Compare comp, Op op
+      , Buf &xbuf)
+{
+   if(first != middle && middle != last && comp(*middle, middle[-1])){
+      typedef typename iterator_traits<RandIt>::size_type   size_type;
+      size_type const len1 = size_type(middle-first);
+      size_type const len2 = size_type(last-middle);
+      if(len1 <= len2){
+         first = boost::movelib::upper_bound(first, middle, *middle, comp);
+         xbuf.move_assign(first, size_type(middle-first));
+         op_merge_with_right_placed
+            (xbuf.data(), xbuf.end(), first, middle, last, comp, op);
+      }
+      else{
+         last = boost::movelib::lower_bound(middle, last, middle[-1], comp);
+         xbuf.move_assign(middle, size_type(last-middle));
+         op_merge_with_left_placed
+            (first, middle, last, xbuf.data(), xbuf.end(), comp, op);
+      }
+   }
+}
+
+template<class RandIt, class Compare, class XBuf>
+void buffered_merge
+      ( RandIt first, RandIt const middle, RandIt last
+      , Compare comp
+      , XBuf &xbuf)
+{
+   op_buffered_merge(first, middle, last, comp, move_op(), xbuf);
+}
+
+// Complexity: 2*distance(first, last)+max_collected^2/2
+//
+// Tries to collect at most n_keys unique elements from [first, last),
+// in the begining of the range, and ordered according to comp
+// 
+// Returns the number of collected keys
+template<class RandIt, class Compare, class XBuf>
+typename iterator_traits<RandIt>::size_type
+   collect_unique
+      ( RandIt const first, RandIt const last
+      , typename iterator_traits<RandIt>::size_type const max_collected, Compare comp
+      , XBuf & xbuf)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type h = 0;
+   if(max_collected){
+      ++h;  // first key is always here
+      RandIt h0 = first;
+      RandIt u = first; ++u;
+      RandIt search_end = u;
+
+      if(xbuf.capacity() >= max_collected){
+         typename XBuf::iterator const ph0 = xbuf.add(first);
+         while(u != last && h < max_collected){
+            typename XBuf::iterator const r = boost::movelib::lower_bound(ph0, xbuf.end(), *u, comp);
+            //If key not found add it to [h, h+h0)
+            if(r == xbuf.end() || comp(*u, *r) ){
+               RandIt const new_h0 = boost::move(search_end, u, h0);
+               search_end = u;
+               ++search_end;
+               ++h;
+               xbuf.insert(r, u);
+               h0 = new_h0;
+            }
+            ++u;
+         }
+         boost::move_backward(first, h0, h0+h);
+         boost::move(xbuf.data(), xbuf.end(), first);
+      }
+      else{
+         while(u != last && h < max_collected){
+            RandIt const r = boost::movelib::lower_bound(h0, search_end, *u, comp);
+            //If key not found add it to [h, h+h0)
+            if(r == search_end || comp(*u, *r) ){
+               RandIt const new_h0 = rotate_gcd(h0, search_end, u);
+               search_end = u;
+               ++search_end;
+               ++h;
+               rotate_gcd(r+(new_h0-h0), u, search_end);
+               h0 = new_h0;
+            }
+            ++u;
+         }
+         rotate_gcd(first, h0, h0+h);
+      }
+   }
+   return h;
+}
+
+template<class Unsigned>
+Unsigned floor_sqrt(Unsigned const n)
+{
+   Unsigned x = n;
+   Unsigned y = x/2 + (x&1);
+   while (y < x){
+      x = y;
+      y = (x + n / x)/2;
+   }
+   return x;
+}
+
+template<class Unsigned>
+Unsigned ceil_sqrt(Unsigned const n)
+{
+   Unsigned r = floor_sqrt(n);
+   return r + Unsigned((n%r) != 0);
+}
+
+template<class Unsigned>
+Unsigned floor_merge_multiple(Unsigned const n, Unsigned &base, Unsigned &pow)
+{
+   Unsigned s = n;
+   Unsigned p = 0;
+   while(s > AdaptiveSortInsertionSortThreshold){
+      s /= 2;
+      ++p;
+   }
+   base = s;
+   pow = p;
+   return s << p;
+}
+
+template<class Unsigned>
+Unsigned ceil_merge_multiple(Unsigned const n, Unsigned &base, Unsigned &pow)
+{
+   Unsigned fm = floor_merge_multiple(n, base, pow);
+
+   if(fm != n){
+      if(base < AdaptiveSortInsertionSortThreshold){
+         ++base;
+      }
+      else{
+         base = AdaptiveSortInsertionSortThreshold/2 + 1;
+         ++pow;
+      }
+   }
+   return base << pow;
+}
+
+template<class Unsigned>
+Unsigned ceil_sqrt_multiple(Unsigned const n, Unsigned *pbase = 0)
+{
+   Unsigned const r = ceil_sqrt(n);
+   Unsigned pow = 0;
+   Unsigned base = 0;
+   Unsigned const res = ceil_merge_multiple(r, base, pow);
+   if(pbase) *pbase = base;
+   return res;
+}
+
+struct less
+{
+   template<class T>
+   bool operator()(const T &l, const T &r)
+   {  return l < r;  }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//                            MERGE BLOCKS
+//
+///////////////////////////////////////////////////////////////////////////////
+
+//#define ADAPTIVE_SORT_MERGE_SLOW_STABLE_SORT_IS_NLOGN
+
+#if defined ADAPTIVE_SORT_MERGE_SLOW_STABLE_SORT_IS_NLOGN
+template<class RandIt, class Compare>
+void slow_stable_sort
+   ( RandIt const first, RandIt const last, Compare comp)
+{
+   boost::movelib::inplace_stable_sort(first, last, comp);
+}
+
+#else //ADAPTIVE_SORT_MERGE_SLOW_STABLE_SORT_IS_NLOGN
+
+template<class RandIt, class Compare>
+void slow_stable_sort
+   ( RandIt const first, RandIt const last, Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type L = size_type(last - first);
+   {  //Use insertion sort to merge first elements
+      size_type m = 0;
+      while((L - m) > size_type(AdaptiveSortInsertionSortThreshold)){
+         insertion_sort(first+m, first+m+size_type(AdaptiveSortInsertionSortThreshold), comp);
+         m += AdaptiveSortInsertionSortThreshold;
+      }
+      insertion_sort(first+m, last, comp);
+   }
+
+   size_type h = AdaptiveSortInsertionSortThreshold;
+   for(bool do_merge = L > h; do_merge; h*=2){
+      do_merge = (L - h) > h;
+      size_type p0 = 0;
+      if(do_merge){
+         size_type const h_2 = 2*h;
+         while((L-p0) > h_2){
+            merge_bufferless(first+p0, first+p0+h, first+p0+h_2, comp);
+            p0 += h_2;
+         }
+      }
+      if((L-p0) > h){
+         merge_bufferless(first+p0, first+p0+h, last, comp);
+      }
+   }
+}
+
+#endif   //ADAPTIVE_SORT_MERGE_SLOW_STABLE_SORT_IS_NLOGN
+
+//Returns new l_block and updates use_buf
+template<class Unsigned>
+Unsigned lblock_for_combine
+   (Unsigned const l_block, Unsigned const n_keys, Unsigned const l_data, bool &use_buf)
+{
+   BOOST_ASSERT(l_data > 1);
+
+   //We need to guarantee lblock >= l_merged/(n_keys/2) keys for the combination.
+   //We have at least 4 keys guaranteed (which are the minimum to merge 2 ranges)
+   //If l_block != 0, then n_keys is already enough to merge all blocks in all
+   //phases as we've found all needed keys for that buffer and length before.
+   //If l_block == 0 then see if half keys can be used as buffer and the rest
+   //as keys guaranteeing that n_keys >= (2*l_merged)/lblock = 
+   if(!l_block){
+      //If l_block == 0 then n_keys is power of two
+      //(guaranteed by build_params(...))
+      BOOST_ASSERT(n_keys >= 4);
+      //BOOST_ASSERT(0 == (n_keys &(n_keys-1)));
+
+      //See if half keys are at least 4 and if half keys fulfill
+      Unsigned const new_buf  = n_keys/2;
+      Unsigned const new_keys = n_keys-new_buf;
+      use_buf = new_keys >= 4 && new_keys >= l_data/new_buf;
+      if(use_buf){
+         return new_buf;
+      }
+      else{
+         return l_data/n_keys;
+      }
+   }
+   else{
+      use_buf = true;
+      return l_block;
+   }
+}
+
+template<class RandIt, class Compare, class XBuf>
+void stable_sort( RandIt first, RandIt last, Compare comp, XBuf & xbuf)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const len = size_type(last - first);
+   size_type const half_len = len/2 + (len&1);
+   if(std::size_t(xbuf.capacity() - xbuf.size()) >= half_len) {
+      merge_sort(first, last, comp, xbuf.data()+xbuf.size());
+   }
+   else{
+      slow_stable_sort(first, last, comp);
+   }
+}
+
+template<class RandIt, class Comp, class XBuf>
+void initialize_keys( RandIt first, RandIt last
+                    , Comp comp
+                    , XBuf & xbuf)
+{
+   stable_sort(first, last, comp, xbuf);
+}
+
+template<class RandIt, class U>
+void initialize_keys( RandIt first, RandIt last
+                    , less
+                    , U &)
+{
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+   std::size_t count = std::size_t(last - first);
+   for(std::size_t i = 0; i != count; ++i){
+      *first = value_type(i);
+      ++first;
+   }
+}
+
+template<class RandIt>
+void move_data_backward( RandIt cur_pos
+              , typename iterator_traits<RandIt>::size_type const l_data
+              , RandIt new_pos
+              , bool const xbuf_used)
+{
+   //Move buffer to the total combination right
+   if(xbuf_used){
+      boost::move_backward(cur_pos, cur_pos+l_data, new_pos+l_data);      
+   }
+   else{
+      boost::adl_move_swap_ranges_backward(cur_pos, cur_pos+l_data, new_pos+l_data);      
+      //Rotate does less moves but it seems slower due to cache issues
+      //rotate_gcd(first-l_block, first+len-l_block, first+len);
+   }
+}
+
+template<class RandIt>
+void move_data_forward( RandIt cur_pos
+              , typename iterator_traits<RandIt>::size_type const l_data
+              , RandIt new_pos
+              , bool const xbuf_used)
+{
+   //Move buffer to the total combination right
+   if(xbuf_used){
+      boost::move(cur_pos, cur_pos+l_data, new_pos);
+   }
+   else{
+      boost::adl_move_swap_ranges(cur_pos, cur_pos+l_data, new_pos);
+      //Rotate does less moves but it seems slower due to cache issues
+      //rotate_gcd(first-l_block, first+len-l_block, first+len);
+   }
+}
+
+template <class Unsigned>
+Unsigned calculate_total_combined(Unsigned const len, Unsigned const l_prev_merged, Unsigned *pl_irreg_combined = 0)
+{
+   typedef Unsigned size_type;
+
+   size_type const l_combined = 2*l_prev_merged;
+   size_type l_irreg_combined = len%l_combined;
+   size_type l_total_combined = len;
+   if(l_irreg_combined <= l_prev_merged){
+      l_total_combined -= l_irreg_combined;
+      l_irreg_combined = 0;
+   }
+   if(pl_irreg_combined)
+      *pl_irreg_combined = l_irreg_combined;
+   return l_total_combined;
+}
+
+template<class RandItKeys, class KeyCompare, class SizeType, class XBuf>
+void combine_params
+   ( RandItKeys const keys
+   , KeyCompare key_comp
+   , SizeType l_combined
+   , SizeType const l_prev_merged
+   , SizeType const l_block
+   , XBuf & xbuf
+   //Output
+   , SizeType &n_block_a
+   , SizeType &n_block_b
+   , SizeType &l_irreg1
+   , SizeType &l_irreg2
+   //Options
+   , bool do_initialize_keys = true)
+{
+   typedef SizeType   size_type;
+
+   //Initial parameters for selection sort blocks
+   l_irreg1 = l_prev_merged%l_block;
+   l_irreg2 = (l_combined-l_irreg1)%l_block;
+   BOOST_ASSERT(((l_combined-l_irreg1-l_irreg2)%l_block) == 0);
+   size_type const n_reg_block = (l_combined-l_irreg1-l_irreg2)/l_block;
+   n_block_a = l_prev_merged/l_block;
+   n_block_b = n_reg_block - n_block_a;
+   BOOST_ASSERT(n_reg_block>=n_block_a);
+
+   //Key initialization
+   if (do_initialize_keys) {
+      initialize_keys(keys, keys + needed_keys_count(n_block_a, n_block_b), key_comp, xbuf);
+   }
+}
+
+template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
+RandItB op_buffered_partial_merge_and_swap_to_range1_and_buffer
+   ( RandIt1 first1, RandIt1 const last1
+   , RandIt2 &rfirst2, RandIt2 const last2, RandIt2 &rfirst_min
+   , RandItB &rfirstb, Compare comp, Op op )
+{
+   RandItB firstb = rfirstb;
+   RandItB lastb  = firstb;
+   RandIt2 first2 = rfirst2;
+
+   //Move to buffer while merging
+   //Three way moves need less moves when op is swap_op so use it
+   //when merging elements from range2 to the destination occupied by range1
+   if(first1 != last1 && first2 != last2){
+      RandIt2 first_min = rfirst_min;
+      op(four_way_t(), first2++, first_min++, first1++, lastb++);
+
+      while(first1 != last1){
+         if(first2 == last2){
+            lastb = op(forward_t(), first1, last1, firstb);
+            break;
+         }
+
+         if(comp(*first_min, *firstb)){
+            op( four_way_t(), first2++, first_min++, first1++, lastb++);
+         }
+         else{
+            op(three_way_t(), firstb++, first1++, lastb++);
+         }
+      }
+      rfirst2 = first2;
+      rfirstb = firstb;
+      rfirst_min = first_min;
+   }
+
+   return lastb;
+}
+
+//////////////////////////////////
+//
+//          partial_merge
+//
+//////////////////////////////////
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge_impl
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op)
+{
+   InputIt1 first1(r_first1);
+   InputIt2 first2(r_first2);
+   if(first2 != last2 && last1 != first1)
+   while(1){
+      if(comp(*first2, *first1)) {
+         op(first2++, d_first++);
+         if(first2 == last2){
+            break;
+         }
+      }
+      else{
+         op(first1++, d_first++);
+         if(first1 == last1){
+            break;
+         }
+      }
+   }
+   r_first1 = first1;
+   r_first2 = first2;
+   return d_first;
+}
+
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op, bool is_stable)
+{
+   return is_stable ? op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, comp, op)
+                    : op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, antistable<Compare>(comp), op);
+}
+
+//////////////////////////////////
+//
+//    partial_merge_and_swap
+//
+//////////////////////////////////
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge_and_swap_impl
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op)
+{
+   InputIt1 first1(r_first1);
+   InputIt2 first2(r_first2);
+   
+   if(first2 != last2 && last1 != first1) {
+      InputIt2 first_min(r_first_min);
+      bool non_empty_ranges = true;
+      do{
+         if(comp(*first_min, *first1)) {
+            op(three_way_t(), first2++, first_min++, d_first++);
+            non_empty_ranges = first2 != last2;
+         }
+         else{
+            op(first1++, d_first++);
+            non_empty_ranges = first1 != last1;
+         }
+      } while(non_empty_ranges);
+      r_first_min = first_min;
+      r_first1 = first1;
+      r_first2 = first2;
+   }
+   return d_first;
+}
+
+template<class RandIt, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge_and_swap
+   (RandIt &r_first1, RandIt const last1, InputIt2 &r_first2, InputIt2 const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op, bool is_stable)
+{
+   return is_stable ? op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, comp, op)
+                    : op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, antistable<Compare>(comp), op);
+}
+
+template<class RandIt, class RandItBuf, class Compare, class Op>
+RandIt op_partial_merge_and_save_impl
+   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
+   , RandItBuf &buf_first1_in_out, RandItBuf &buf_last1_in_out
+   , Compare comp, Op op
+   )
+{
+   RandItBuf buf_first1 = buf_first1_in_out;
+   RandItBuf buf_last1  = buf_last1_in_out;
+   RandIt first2(rfirst2);
+
+   bool const do_swap = first2 != first_min;
+   if(buf_first1 == buf_last1){
+      //Skip any element that does not need to be moved
+      RandIt new_first1 = skip_until_merge(first1, last1, *first_min, comp);
+      buf_first1 += (new_first1-first1);
+      first1 = new_first1;
+      buf_last1  = do_swap ? op_buffered_partial_merge_and_swap_to_range1_and_buffer(first1, last1, first2, last2, first_min, buf_first1, comp, op)
+                           : op_buffered_partial_merge_to_range1_and_buffer    (first1, last1, first2, last2, buf_first1, comp, op);
+      first1 = last1;
+   }
+   else{
+      BOOST_ASSERT((last1-first1) == (buf_last1 - buf_first1));
+   }
+
+   //Now merge from buffer
+   first1 = do_swap ? op_partial_merge_and_swap_impl(buf_first1, buf_last1, first2, last2, first_min, first1, comp, op)
+                    : op_partial_merge_impl    (buf_first1, buf_last1, first2, last2, first1, comp, op);
+   buf_first1_in_out = buf_first1;
+   buf_last1_in_out  = buf_last1;
+   rfirst2 = first2;
+   return first1;
+}
+
+template<class RandIt, class RandItBuf, class Compare, class Op>
+RandIt op_partial_merge_and_save
+   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
+   , RandItBuf &buf_first1_in_out
+   , RandItBuf &buf_last1_in_out
+   , Compare comp
+   , Op op
+   , bool is_stable)
+{
+   return is_stable
+      ? op_partial_merge_and_save_impl
+         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, comp, op)
+      : op_partial_merge_and_save_impl
+         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, antistable<Compare>(comp), op)
+      ;
+}
+
+
+
+template<class RandItKeys, class KeyCompare, class RandIt, class RandIt2, class OutputIt, class Compare, class Op>
+OutputIt op_merge_blocks_with_irreg
+   ( RandItKeys key_first
+   , RandItKeys key_mid
+   , KeyCompare key_comp
+   , RandIt first_reg
+   , RandIt2 &first_irr
+   , RandIt2 const last_irr
+   , OutputIt dest
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type n_block_left
+   , typename iterator_traits<RandIt>::size_type min_check
+   , typename iterator_traits<RandIt>::size_type max_check
+   , Compare comp, bool const is_stable, Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+
+   for(; n_block_left; --n_block_left, ++key_first, min_check -= min_check != 0, max_check -= max_check != 0){
+      size_type next_key_idx = find_next_block(key_first, key_comp, first_reg, l_block, min_check, max_check, comp);  
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt const last_reg  = first_reg + l_block;
+      RandIt first_min = first_reg + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_reg, last_reg, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!next_key_idx || is_sorted(first_min, last_min, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((!next_key_idx || !comp(*first_reg, *first_min )));
+
+      OutputIt orig_dest = dest; (void)orig_dest;
+      dest = next_key_idx ? op_partial_merge_and_swap(first_irr, last_irr, first_reg, last_reg, first_min, dest, comp, op, is_stable)
+                          : op_partial_merge         (first_irr, last_irr, first_reg, last_reg, dest, comp, op, is_stable);
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+
+      if(first_reg == dest){
+         dest = next_key_idx ? ::boost::adl_move_swap_ranges(first_min, last_min, first_reg)
+                             : last_reg;
+      }
+      else{
+         dest = next_key_idx ? op(three_way_forward_t(), first_reg, last_reg, first_min, dest)
+                             : op(forward_t(), first_reg, last_reg, dest);
+      }
+
+      RandItKeys const key_next(key_first + next_key_idx);
+      swap_and_update_key(key_next, key_first, key_mid, last_reg, last_reg, first_min);
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+      first_reg = last_reg;
+   }
+   return dest;
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op>
+void op_merge_blocks_left
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp, Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+//   BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
+
+   size_type n_block_b_left = n_block_b;
+   size_type n_block_a_left = n_block_a;
+   size_type n_block_left = n_block_b + n_block_a;
+   RandItKeys key_mid(key_first + n_block_a);
+
+   RandIt buffer = first - l_block;
+   RandIt first1 = first;
+   RandIt last1  = first1 + l_irreg1;
+   RandIt first2 = last1;
+   RandIt const irreg2 = first2 + n_block_left*l_block;
+   bool is_range1_A = true;
+
+   RandItKeys key_range2(key_first);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process all regular blocks before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+   size_type max_check = min_value(min_check+1, n_block_left);
+   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
+      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt const first_min = first2 + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last2  = first2 + l_block;
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first1, last1, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+
+      //Check if irregular b block should go here.
+      //If so, break to the special code handling the irregular block
+      if (!n_block_b_left &&
+            ( (l_irreg2 && comp(*irreg2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
+         break;
+      }
+
+      RandItKeys const key_next(key_range2 + next_key_idx);
+      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
+
+      bool const is_buffer_middle = last1 == buffer;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT( ( is_buffer_middle && size_type(first2-buffer) == l_block && buffer == last1) ||
+                                          (!is_buffer_middle && size_type(first1-buffer) == l_block && first2 == last1));
+
+      if(is_range1_A == is_range2_A){
+         BOOST_ASSERT((first1 == last1) || !comp(*first_min, last1[-1]));
+         if(!is_buffer_middle){
+            buffer = op(forward_t(), first1, last1, buffer);
+         }
+         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+         first1 = first2;
+         last1  = last2;
+      }
+      else {
+         RandIt unmerged;
+         RandIt buf_beg;
+         RandIt buf_end;
+         if(is_buffer_middle){
+            buf_end = buf_beg = first2 - (last1-first1);
+            unmerged = op_partial_merge_and_save( first1, last1, first2, last2, first_min
+                                                , buf_beg, buf_end, comp, op, is_range1_A);
+         }  
+         else{
+            buf_beg = first1;
+            buf_end = last1;
+            unmerged = op_partial_merge_and_save
+               (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
+         }
+         (void)unmerged;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, unmerged, comp));
+
+         swap_and_update_key( key_next, key_range2, key_mid, first2, last2
+                            , last_min - size_type(last2 - first2));
+
+         if(buf_beg != buf_end){  //range2 exhausted: is_buffer_middle for the next iteration
+            first1 = buf_beg;
+            last1  = buf_end;
+            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buf_end == (last2-l_block));
+            buffer = last1;
+         }
+         else{ //range1 exhausted: !is_buffer_middle for the next iteration
+            first1 = first2;
+            last1  = last2;
+            buffer = first2 - l_block;
+            is_range1_A = is_range2_A;
+         }
+      }
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
+      is_range2_A ? --n_block_a_left : --n_block_b_left;
+      first2 = last2;
+   }
+
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_range2 + n_block_left, key_comp, *key_mid));
+   BOOST_ASSERT(!n_block_b_left);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process remaining range 1 left before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   bool const is_buffer_middle = last1 == buffer;
+   RandIt first_irr2 = irreg2;
+   RandIt const last_irr2  = first_irr2 + l_irreg2;
+   if(l_irreg2 && is_range1_A){
+      if(is_buffer_middle){
+         first1 = skip_until_merge(first1, last1, *first_irr2, comp);
+         //Even if we copy backward, no overlapping occurs so use forward copy
+         //that can be faster specially with trivial types
+         RandIt const new_first1 = first2 - (last1 - first1);
+         op(forward_t(), first1, last1, new_first1);
+         first1 = new_first1;
+         last1 = first2;
+         buffer = first1 - l_block;
+      }
+      buffer = op_partial_merge_impl(first1, last1, first_irr2, last_irr2, buffer, comp, op);
+      buffer = op(forward_t(), first1, last1, buffer);
+   }
+   else if(!is_buffer_middle){
+      buffer = op(forward_t(), first1, last1, buffer);
+   }
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process irregular B block and remaining A blocks
+   ////////////////////////////////////////////////////////////////////////////
+   buffer = op_merge_blocks_with_irreg
+      ( key_range2, key_mid, key_comp, first2, first_irr2, last_irr2
+      , buffer, l_block, n_block_left, min_check, max_check, comp, false, op);
+   buffer = op(forward_t(), first_irr2, last_irr2, buffer);(void)buffer;
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+}
+
+// first - first element to merge.
+// first[-l_block, 0) - buffer (if use_buf == true)
+// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
+// keys - sequence of keys, in same order as blocks. key<midkey means stream A
+// n_bef_irreg2/n_aft_irreg2 are regular blocks
+// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
+// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+void merge_blocks_left
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , bool const xbuf_used)
+{
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + needed_keys_count(n_block_a, n_block_b), key_comp, key_first[n_block_a]));
+   if(xbuf_used){
+      op_merge_blocks_left
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op());
+   }
+   else{
+      op_merge_blocks_left
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op());
+   }
+}
+
+
+// first - first element to merge.
+// [first+l_block*(n_bef_irreg2+n_aft_irreg2)+l_irreg2, first+l_block*(n_bef_irreg2+n_aft_irreg2+1)+l_irreg2) - buffer
+// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
+// keys - sequence of keys, in same order as blocks. key<midkey means stream A
+// n_bef_irreg2/n_aft_irreg2 are regular blocks
+// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
+// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+void merge_blocks_right
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , bool const xbuf_used)
+{
+   merge_blocks_left
+      ( (make_reverse_iterator)(key_first + needed_keys_count(n_block_a, n_block_b))
+      , inverse<KeyCompare>(key_comp)
+      , (make_reverse_iterator)(first + ((n_block_a+n_block_b)*l_block+l_irreg2))
+      , l_block
+      , l_irreg2
+      , n_block_b
+      , n_block_a
+      , 0
+      , inverse<Compare>(comp), xbuf_used);
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op, class RandItBuf>
+void op_merge_blocks_with_buf
+   ( RandItKeys key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , Op op
+   , RandItBuf const buf_first)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   //BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
+
+   size_type n_block_b_left = n_block_b;
+   size_type n_block_a_left = n_block_a;
+   size_type n_block_left = n_block_b + n_block_a;
+   RandItKeys key_mid(key_first + n_block_a);
+
+   RandItBuf buffer = buf_first;
+   RandItBuf buffer_end = buffer;
+   RandIt first1 = first;
+   RandIt last1  = first1 + l_irreg1;
+   RandIt first2 = last1;
+   RandIt const first_irr2 = first2 + n_block_left*l_block;
+   bool is_range1_A = true;
+
+   RandItKeys key_range2(key_first);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process all regular blocks before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+   size_type max_check = min_value(min_check+1, n_block_left);
+   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
+      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt       first_min = first2 + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last2  = first2 + l_block;
+
+      bool const buffer_empty = buffer == buffer_end; (void)buffer_empty;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buffer_empty ? is_sorted(first1, last1, comp) : is_sorted(buffer, buffer_end, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+
+      //Check if irregular b block should go here.
+      //If so, break to the special code handling the irregular block
+      if (!n_block_b_left &&
+            ( (l_irreg2 && comp(*first_irr2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
+         break;
+      }
+
+      RandItKeys const key_next(key_range2 + next_key_idx);
+      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
+
+      if(is_range1_A == is_range2_A){
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((first1 == last1) || (buffer_empty ? !comp(*first_min, last1[-1]) : !comp(*first_min, buffer_end[-1])));
+         //If buffered, put those elements in place
+         RandIt res = op(forward_t(), buffer, buffer_end, first1);
+         buffer    = buffer_end = buf_first;
+         BOOST_ASSERT(buffer_empty || res == last1); (void)res;
+         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         first1 = first2;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
+      }
+      else {
+         RandIt const unmerged = op_partial_merge_and_save(first1, last1, first2, last2, first_min, buffer, buffer_end, comp, op, is_range1_A);
+         bool const is_range_1_empty = buffer == buffer_end;
+         BOOST_ASSERT(is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged));
+         if(is_range_1_empty){
+            buffer    = buffer_end = buf_first;
+            first_min = last_min - (last2 - first2);
+         }
+         else{
+            first_min = last_min;
+         }
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!is_range_1_empty || (last_min-first_min) == (last2-unmerged));
+         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         is_range1_A ^= is_range_1_empty;
+         first1 = unmerged;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, unmerged, comp));
+      }
+      BOOST_ASSERT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
+      is_range2_A ? --n_block_a_left : --n_block_b_left;
+      last1 += l_block;
+      first2 = last2;
+   }
+
+   RandIt res = op(forward_t(), buffer, buffer_end, first1); (void)res;
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, res, comp));
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process irregular B block and remaining A blocks
+   ////////////////////////////////////////////////////////////////////////////
+   RandIt const last_irr2 = first_irr2 + l_irreg2;
+   op(forward_t(), first_irr2, first_irr2+l_irreg2, buf_first);
+   buffer = buf_first;
+   buffer_end = buffer+l_irreg2;
+
+   reverse_iterator<RandItBuf> rbuf_beg(buffer_end);
+   RandIt dest = op_merge_blocks_with_irreg
+      ((make_reverse_iterator)(key_first + n_block_b + n_block_a), (make_reverse_iterator)(key_mid), inverse<KeyCompare>(key_comp)
+      , (make_reverse_iterator)(first_irr2), rbuf_beg
+      , (make_reverse_iterator)(buffer), (make_reverse_iterator)(last_irr2)
+      , l_block, n_block_left, 0, n_block_left
+      , inverse<Compare>(comp), true, op).base();
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(dest, last_irr2, comp));
+
+   buffer_end = rbuf_beg.base();
+   BOOST_ASSERT((dest-last1) == (buffer_end-buffer));
+   op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);
+
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class RandItBuf>
+void merge_blocks_with_buf
+   ( RandItKeys key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , RandItBuf const buf_first
+   , bool const xbuf_used)
+{
+   if(xbuf_used){
+      op_merge_blocks_with_buf
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op(), buf_first);
+   }
+   else{
+      op_merge_blocks_with_buf
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op(), buf_first);
+   }
+}
+
+template<class RandIt, class Compare, class Op>
+typename iterator_traits<RandIt>::size_type
+   op_insertion_sort_step_left
+      ( RandIt const first
+      , typename iterator_traits<RandIt>::size_type const length
+      , typename iterator_traits<RandIt>::size_type const step
+      , Compare comp, Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const s = min_value<size_type>(step, AdaptiveSortInsertionSortThreshold);
+   size_type m = 0;
+
+   while((length - m) > s){
+      insertion_sort_op(first+m, first+m+s, first+m-s, comp, op);
+      m += s;
+   }
+   insertion_sort_op(first+m, first+length, first+m-s, comp, op);
+   return s;
+}
+
+template<class RandIt, class Compare>
+typename iterator_traits<RandIt>::size_type
+   insertion_sort_step
+      ( RandIt const first
+      , typename iterator_traits<RandIt>::size_type const length
+      , typename iterator_traits<RandIt>::size_type const step
+      , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const s = min_value<size_type>(step, AdaptiveSortInsertionSortThreshold);
+   size_type m = 0;
+
+   while((length - m) > s){
+      insertion_sort(first+m, first+m+s, comp);
+      m += s;
+   }
+   insertion_sort(first+m, first+length, comp);
+   return s;
+}
+
+template<class RandIt, class Compare, class Op>
+typename iterator_traits<RandIt>::size_type  
+   op_merge_left_step_multiple
+      ( RandIt first_block
+      , typename iterator_traits<RandIt>::size_type const elements_in_blocks
+      , typename iterator_traits<RandIt>::size_type l_merged
+      , typename iterator_traits<RandIt>::size_type const l_build_buf
+      , typename iterator_traits<RandIt>::size_type l_left_space
+      , Compare comp
+      , Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   for(; l_merged < l_build_buf && l_left_space >= l_merged; l_merged*=2){
+      size_type p0=0;
+      RandIt pos = first_block;
+      while((elements_in_blocks - p0) > 2*l_merged) {
+         op_merge_left(pos-l_merged, pos, pos+l_merged, pos+2*l_merged, comp, op);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos+l_merged, comp));
+         p0 += 2*l_merged;
+         pos = first_block+p0;
+      }
+      if((elements_in_blocks-p0) > l_merged) {
+         op_merge_left(pos-l_merged, pos, pos+l_merged, first_block+elements_in_blocks, comp, op);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos-l_merged+(first_block+elements_in_blocks-pos), comp));
+      }
+      else {
+         op(forward_t(), pos, first_block+elements_in_blocks, pos-l_merged);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, first_block+elements_in_blocks-l_merged, comp));
+      }
+      first_block -= l_merged;
+      l_left_space -= l_merged;
+   }
+   return l_merged;
+}
+
+template<class RandIt, class Compare, class Op>
+void op_merge_right_step_once
+      ( RandIt first_block
+      , typename iterator_traits<RandIt>::size_type const elements_in_blocks
+      , typename iterator_traits<RandIt>::size_type const l_build_buf
+      , Compare comp
+      , Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type restk = elements_in_blocks%(2*l_build_buf);
+   size_type p = elements_in_blocks - restk;
+   BOOST_ASSERT(0 == (p%(2*l_build_buf)));
+
+   if(restk <= l_build_buf){
+      op(backward_t(),first_block+p, first_block+p+restk, first_block+p+restk+l_build_buf);
+   }
+   else{
+      op_merge_right(first_block+p, first_block+p+l_build_buf, first_block+p+restk, first_block+p+restk+l_build_buf, comp, op);
+   }
+   while(p>0){
+      p -= 2*l_build_buf;
+      op_merge_right(first_block+p, first_block+p+l_build_buf, first_block+p+2*l_build_buf, first_block+p+3*l_build_buf, comp, op);
+   }
+}
+
+
+// build blocks of length 2*l_build_buf. l_build_buf is power of two
+// input: [0, l_build_buf) elements are buffer, rest unsorted elements
+// output: [0, l_build_buf) elements are buffer, blocks 2*l_build_buf and last subblock sorted
+//
+// First elements are merged from right to left until elements start
+// at first. All old elements [first, first + l_build_buf) are placed at the end
+// [first+len-l_build_buf, first+len). To achieve this:
+// - If we have external memory to merge, we save elements from the buffer
+//   so that a non-swapping merge is used. Buffer elements are restored
+//   at the end of the buffer from the external memory.
+//
+// - When the external memory is not available or it is insufficient
+//   for a merge operation, left swap merging is used.
+//
+// Once elements are merged left to right in blocks of l_build_buf, then a single left
+// to right merge step is performed to achieve merged blocks of size 2K.
+// If external memory is available, usual merge is used, swap merging otherwise.
+//
+// As a last step, if auxiliary memory is available in-place merge is performed.
+// until all is merged or auxiliary memory is not large enough.
+template<class RandIt, class Compare, class XBuf>
+typename iterator_traits<RandIt>::size_type  
+   adaptive_sort_build_blocks
+      ( RandIt const first
+      , typename iterator_traits<RandIt>::size_type const len
+      , typename iterator_traits<RandIt>::size_type const l_base
+      , typename iterator_traits<RandIt>::size_type const l_build_buf
+      , XBuf & xbuf
+      , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   BOOST_ASSERT(l_build_buf <= len);
+   BOOST_ASSERT(0 == ((l_build_buf / l_base)&(l_build_buf/l_base-1)));
+
+   //Place the start pointer after the buffer
+   RandIt first_block = first + l_build_buf;
+   size_type const elements_in_blocks = len - l_build_buf;
+
+   //////////////////////////////////
+   // Start of merge to left step
+   //////////////////////////////////
+   size_type l_merged = 0u;
+
+   BOOST_ASSERT(l_build_buf);
+   //If there is no enough buffer for the insertion sort step, just avoid the external buffer
+   size_type kbuf = min_value<size_type>(l_build_buf, size_type(xbuf.capacity()));
+   kbuf = kbuf < l_base ? 0 : kbuf;
+
+   if(kbuf){
+      //Backup internal buffer values in external buffer so they can be overwritten
+      xbuf.move_assign(first+l_build_buf-kbuf, kbuf);
+      l_merged = op_insertion_sort_step_left(first_block, elements_in_blocks, l_base, comp, move_op());
+
+      //Now combine them using the buffer. Elements from buffer can be
+      //overwritten since they've been saved to xbuf
+      l_merged = op_merge_left_step_multiple
+         ( first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, kbuf - l_merged, comp, move_op());
+
+      //Restore internal buffer from external buffer unless kbuf was l_build_buf,
+      //in that case restoration will happen later
+      if(kbuf != l_build_buf){
+         boost::move(xbuf.data()+kbuf-l_merged, xbuf.data() + kbuf, first_block-l_merged+elements_in_blocks);
+      }
+   }
+   else{
+      l_merged = insertion_sort_step(first_block, elements_in_blocks, l_base, comp);
+      rotate_gcd(first_block - l_merged, first_block, first_block+elements_in_blocks);
+   }
+
+   //Now combine elements using the buffer. Elements from buffer can't be
+   //overwritten since xbuf was not big enough, so merge swapping elements.
+   l_merged = op_merge_left_step_multiple
+      (first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, l_build_buf - l_merged, comp, swap_op());
+
+   BOOST_ASSERT(l_merged == l_build_buf);
+
+   //////////////////////////////////
+   // Start of merge to right step
+   //////////////////////////////////
+
+   //If kbuf is l_build_buf then we can merge right without swapping
+   //Saved data is still in xbuf
+   if(kbuf && kbuf == l_build_buf){
+      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, move_op());
+      //Restore internal buffer from external buffer if kbuf was l_build_buf.
+      //as this operation was previously delayed.
+      boost::move(xbuf.data(), xbuf.data() + kbuf, first);
+   }
+   else{
+      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, swap_op());
+   }
+   xbuf.clear();
+   //2*l_build_buf or total already merged
+   return min_value(elements_in_blocks, 2*l_build_buf);
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
+void adaptive_sort_combine_blocks
+   ( RandItKeys const keys
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const len
+   , typename iterator_traits<RandIt>::size_type const l_prev_merged
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , bool const use_buf
+   , bool const xbuf_used
+   , XBuf & xbuf
+   , Compare comp
+   , bool merge_left)
+{
+   (void)xbuf;
+   typedef typename iterator_traits<RandIt>::size_type   size_type;
+
+   size_type const l_reg_combined   = 2*l_prev_merged;
+   size_type l_irreg_combined = 0;
+   size_type const l_total_combined = calculate_total_combined(len, l_prev_merged, &l_irreg_combined);
+   size_type const n_reg_combined = len/l_reg_combined;
+   RandIt combined_first = first;
+
+   (void)l_total_combined;
+   BOOST_ASSERT(l_total_combined <= len);
+
+   size_type const max_i = n_reg_combined + (l_irreg_combined != 0);
+
+   if(merge_left || !use_buf) {
+      for( size_type combined_i = 0; combined_i != max_i; ++combined_i, combined_first += l_reg_combined) {
+         //Now merge blocks
+         bool const is_last = combined_i==n_reg_combined;
+         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
+
+         range_xbuf<RandIt, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, key_comp, l_cur_combined
+                        , l_prev_merged, l_block, rbuf
+                        , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combpar:            ", len + l_block);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         if(!use_buf){
+            merge_blocks_bufferless
+               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp);
+         }
+         else{
+            merge_blocks_left
+               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
+         }
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   After merge_blocks_L: ", len + l_block);
+      }
+   }
+   else{
+      combined_first += l_reg_combined*(max_i-1);
+      for( size_type combined_i = max_i; combined_i--; combined_first -= l_reg_combined) {
+         bool const is_last = combined_i==n_reg_combined;
+         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
+
+         RandIt const combined_last(combined_first+l_cur_combined);
+         range_xbuf<RandIt, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, key_comp, l_cur_combined
+                        , l_prev_merged, l_block, rbuf
+                        , n_block_a, n_block_b, l_irreg1, l_irreg2);  //Outputs
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combpar:            ", len + l_block);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         merge_blocks_right
+            (keys, key_comp, combined_first, l_block, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   After merge_blocks_R: ", len + l_block);
+      }
+   }
+}
+
+//Returns true if buffer is placed in 
+//[buffer+len-l_intbuf, buffer+len). Otherwise, buffer is
+//[buffer,buffer+l_intbuf)
+template<class RandIt, class Compare, class XBuf>
+bool adaptive_sort_combine_all_blocks
+   ( RandIt keys
+   , typename iterator_traits<RandIt>::size_type &n_keys
+   , RandIt const buffer
+   , typename iterator_traits<RandIt>::size_type const l_buf_plus_data
+   , typename iterator_traits<RandIt>::size_type l_merged
+   , typename iterator_traits<RandIt>::size_type &l_intbuf
+   , XBuf & xbuf
+   , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   RandIt const first = buffer + l_intbuf;
+   size_type const l_data = l_buf_plus_data - l_intbuf;
+   size_type const l_unique = l_intbuf+n_keys;
+   //Backup data to external buffer once if possible
+   bool const common_xbuf = l_data > l_merged && l_intbuf && l_intbuf <= xbuf.capacity();
+   if(common_xbuf){
+      xbuf.move_assign(buffer, l_intbuf);
+   }
+
+   bool prev_merge_left = true;
+   size_type l_prev_total_combined = l_merged, l_prev_block = 0;
+   bool prev_use_internal_buf = true;
+
+   for( size_type n = 0; l_data > l_merged
+      ; l_merged*=2
+      , ++n){
+      //If l_intbuf is non-zero, use that internal buffer.
+      //    Implies l_block == l_intbuf && use_internal_buf == true
+      //If l_intbuf is zero, see if half keys can be reused as a reduced emergency buffer,
+      //    Implies l_block == n_keys/2 && use_internal_buf == true
+      //Otherwise, just give up and and use all keys to merge using rotations (use_internal_buf = false)
+      bool use_internal_buf = false;
+      size_type const l_block = lblock_for_combine(l_intbuf, n_keys, 2*l_merged, use_internal_buf);
+      BOOST_ASSERT(!l_intbuf || (l_block == l_intbuf));
+      BOOST_ASSERT(n == 0 || (!use_internal_buf || prev_use_internal_buf) );
+      BOOST_ASSERT(n == 0 || (!use_internal_buf || l_prev_block == l_block) );
+      
+      bool const is_merge_left = (n&1) == 0;
+      size_type const l_total_combined = calculate_total_combined(l_data, l_merged);
+      if(n && prev_use_internal_buf && prev_merge_left){
+         if(is_merge_left || !use_internal_buf){
+            move_data_backward(first-l_prev_block, l_prev_total_combined, first, common_xbuf);
+         }
+         else{
+            //Put the buffer just after l_total_combined
+            RandIt const buf_end = first+l_prev_total_combined;
+            RandIt const buf_beg = buf_end-l_block;
+            if(l_prev_total_combined > l_total_combined){
+               size_type const l_diff = l_prev_total_combined - l_total_combined;
+               move_data_backward(buf_beg-l_diff, l_diff, buf_end-l_diff, common_xbuf);
+            }
+            else if(l_prev_total_combined < l_total_combined){
+               size_type const l_diff = l_total_combined - l_prev_total_combined;
+               move_data_forward(buf_end, l_diff, buf_beg, common_xbuf);
+            }
+         }
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   After move_data     : ", l_data + l_intbuf);
+      }
+
+      //Combine to form l_merged*2 segments
+      if(n_keys){
+         adaptive_sort_combine_blocks
+            ( keys, comp, !use_internal_buf || is_merge_left ? first : first-l_block
+            , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
+      }
+      else{
+         size_type *const uint_keys = xbuf.template aligned_trailing<size_type>();
+         adaptive_sort_combine_blocks
+            ( uint_keys, less(), !use_internal_buf || is_merge_left ? first : first-l_block
+            , l_data, l_merged, l_block, use_internal_buf, common_xbuf, xbuf, comp, is_merge_left);
+      }
+
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1(is_merge_left ? "   After comb blocks L:  " : "   After comb blocks R:  ", l_data + l_intbuf);
+      prev_merge_left = is_merge_left;
+      l_prev_total_combined = l_total_combined;
+      l_prev_block = l_block;
+      prev_use_internal_buf = use_internal_buf;
+   }
+   BOOST_ASSERT(l_prev_total_combined == l_data);
+   bool const buffer_right = prev_use_internal_buf && prev_merge_left;
+
+   l_intbuf = prev_use_internal_buf ? l_prev_block : 0u;
+   n_keys = l_unique - l_intbuf;
+   //Restore data from to external common buffer if used
+   if(common_xbuf){
+      if(buffer_right){
+         boost::move(xbuf.data(), xbuf.data() + l_intbuf, buffer+l_data);
+      }
+      else{
+         boost::move(xbuf.data(), xbuf.data() + l_intbuf, buffer);
+      }
+   }
+   return buffer_right;
+}
+
+template<class RandIt, class Compare, class XBuf>
+void stable_merge
+      ( RandIt first, RandIt const middle, RandIt last
+      , Compare comp
+      , XBuf &xbuf)
+{
+   BOOST_ASSERT(xbuf.empty());
+   typedef typename iterator_traits<RandIt>::size_type   size_type;
+   size_type const len1  = size_type(middle-first);
+   size_type const len2  = size_type(last-middle);
+   size_type const l_min = min_value(len1, len2);
+   if(xbuf.capacity() >= l_min){
+      buffered_merge(first, middle, last, comp, xbuf);
+      xbuf.clear();
+   }
+   else{
+      merge_bufferless(first, middle, last, comp);
+   }
+}
+
+
+template<class RandIt, class Compare, class XBuf>
+void adaptive_sort_final_merge( bool buffer_right
+                              , RandIt const first
+                              , typename iterator_traits<RandIt>::size_type const l_intbuf
+                              , typename iterator_traits<RandIt>::size_type const n_keys
+                              , typename iterator_traits<RandIt>::size_type const len
+                              , XBuf & xbuf
+                              , Compare comp)
+{
+   //BOOST_ASSERT(n_keys || xbuf.size() == l_intbuf);
+   xbuf.clear();
+
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   size_type const n_key_plus_buf = l_intbuf+n_keys;
+   if(buffer_right){
+      stable_sort(first+len-l_intbuf, first+len, comp, xbuf);
+      stable_merge(first+n_keys, first+len-l_intbuf, first+len, antistable<Compare>(comp), xbuf);
+      stable_sort(first, first+n_keys, comp, xbuf);
+      stable_merge(first, first+n_keys, first+len, comp, xbuf);
+   }
+   else{
+      stable_sort(first, first+n_key_plus_buf, comp, xbuf);
+      if(xbuf.capacity() >= n_key_plus_buf){
+         buffered_merge(first, first+n_key_plus_buf, first+len, comp, xbuf);
+      }
+      else if(xbuf.capacity() >= min_value<size_type>(l_intbuf, n_keys)){
+         stable_merge(first+n_keys, first+n_key_plus_buf, first+len, comp, xbuf);
+         stable_merge(first, first+n_keys, first+len, comp, xbuf);
+      }
+      else{
+         merge_bufferless(first, first+n_key_plus_buf, first+len, comp);
+      }
+   }
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   After final_merge   : ", len);
+}
+
+template<class RandIt, class Compare, class Unsigned, class XBuf>
+bool adaptive_sort_build_params
+   (RandIt first, Unsigned const len, Compare comp
+   , Unsigned &n_keys, Unsigned &l_intbuf, Unsigned &l_base, Unsigned &l_build_buf
+   , XBuf & xbuf
+   )
+{
+   typedef Unsigned size_type;
+
+   //Calculate ideal parameters and try to collect needed unique keys
+   l_base = 0u;
+
+   //Try to find a value near sqrt(len) that is 2^N*l_base where
+   //l_base <= AdaptiveSortInsertionSortThreshold. This property is important
+   //as build_blocks merges to the left iteratively duplicating the
+   //merged size and all the buffer must be used just before the final
+   //merge to right step. This guarantees "build_blocks" produces 
+   //segments of size l_build_buf*2, maximizing the classic merge phase.
+   l_intbuf = size_type(ceil_sqrt_multiple(len, &l_base));
+
+   //The internal buffer can be expanded if there is enough external memory
+   while(xbuf.capacity() >= l_intbuf*2){
+      l_intbuf *= 2;
+   }
+
+   //This is the minimum number of keys to implement the ideal algorithm
+   //
+   //l_intbuf is used as buffer plus the key count
+   size_type n_min_ideal_keys = l_intbuf-1;
+   while(n_min_ideal_keys >= (len-l_intbuf-n_min_ideal_keys)/l_intbuf){
+      --n_min_ideal_keys;
+   }
+   n_min_ideal_keys += 1;
+   BOOST_ASSERT(n_min_ideal_keys <= l_intbuf);
+
+   if(xbuf.template supports_aligned_trailing<size_type>(l_intbuf, (len-l_intbuf-1)/l_intbuf+1)){
+      n_keys = 0u;
+      l_build_buf = l_intbuf;
+   }
+   else{
+      //Try to achieve a l_build_buf of length l_intbuf*2, so that we can merge with that
+      //l_intbuf*2 buffer in "build_blocks" and use half of them as buffer and the other half
+      //as keys in combine_all_blocks. In that case n_keys >= n_min_ideal_keys but by a small margin.
+      //
+      //If available memory is 2*sqrt(l), then only sqrt(l) unique keys are needed,
+      //(to be used for keys in combine_all_blocks) as the whole l_build_buf
+      //will be backuped in the buffer during build_blocks.
+      bool const non_unique_buf = xbuf.capacity() >= l_intbuf;
+      size_type const to_collect = non_unique_buf ? n_min_ideal_keys : l_intbuf*2;
+      size_type collected = collect_unique(first, first+len, to_collect, comp, xbuf);
+
+      //If available memory is 2*sqrt(l), then for "build_params" 
+      //the situation is the same as if 2*l_intbuf were collected.
+      if(non_unique_buf && collected == n_min_ideal_keys){
+         l_build_buf = l_intbuf;
+         n_keys = n_min_ideal_keys;
+      }
+      else if(collected == 2*l_intbuf){
+         //l_intbuf*2 elements found. Use all of them in the build phase 
+         l_build_buf = l_intbuf*2;
+         n_keys = l_intbuf;
+      }
+      else if(collected == (n_min_ideal_keys+l_intbuf)){ 
+         l_build_buf = l_intbuf;
+         n_keys = n_min_ideal_keys;
+      }
+      //If collected keys are not enough, try to fix n_keys and l_intbuf. If no fix
+      //is possible (due to very low unique keys), then go to a slow sort based on rotations.
+      else{
+         BOOST_ASSERT(collected < (n_min_ideal_keys+l_intbuf));
+         if(collected < 4){  //No combination possible with less that 4 keys
+            return false;
+         }
+         n_keys = l_intbuf;
+         while(n_keys&(n_keys-1)){
+            n_keys &= n_keys-1;  // make it power or 2
+         }
+         while(n_keys > collected){
+            n_keys/=2;
+         }
+         //AdaptiveSortInsertionSortThreshold is always power of two so the minimum is power of two
+         l_base = min_value<Unsigned>(n_keys, AdaptiveSortInsertionSortThreshold);
+         l_intbuf = 0;
+         l_build_buf = n_keys;
+      }
+      BOOST_ASSERT((n_keys+l_intbuf) >= l_build_buf);
+   }
+
+   return true;
+}
+
+template<class RandIt, class Compare, class XBuf>
+inline void adaptive_merge_combine_blocks( RandIt first
+                                      , typename iterator_traits<RandIt>::size_type len1
+                                      , typename iterator_traits<RandIt>::size_type len2
+                                      , typename iterator_traits<RandIt>::size_type collected
+                                      , typename iterator_traits<RandIt>::size_type n_keys
+                                      , typename iterator_traits<RandIt>::size_type l_block
+                                      , bool use_internal_buf
+                                      , bool xbuf_used
+                                      , Compare comp
+                                      , XBuf & xbuf
+                                      )
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const len = len1+len2;
+   size_type const l_combine  = len-collected;
+   size_type const l_combine1 = len1-collected;
+
+    if(n_keys){
+      RandIt const first_data = first+collected;
+      RandIt const keys = first;
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combine: ", len);
+      if(xbuf_used){
+         if(xbuf.size() < l_block){
+            xbuf.initialize_until(l_block, *first);
+         }
+         BOOST_ASSERT(xbuf.size() >= l_block);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, comp, l_combine
+                           , l_combine1, l_block, xbuf
+                           , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
+         merge_blocks_with_buf
+            (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, xbuf.data(), xbuf_used);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A mrg xbf: ", len);
+      }
+      else{
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, comp, l_combine
+                           , l_combine1, l_block, xbuf
+                           , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
+         if(use_internal_buf){
+            merge_blocks_with_buf
+               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, first_data-l_block, xbuf_used);
+            BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A mrg buf: ", len);
+         }
+         else{
+            merge_blocks_bufferless
+               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp);
+            BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A mrg nbf: ", len);
+         }
+      }
+   }
+   else{
+      xbuf.shrink_to_fit(l_block);
+      if(xbuf.size() < l_block){
+         xbuf.initialize_until(l_block, *first);
+      }
+      size_type *const uint_keys = xbuf.template aligned_trailing<size_type>(l_block);
+      size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+      combine_params( uint_keys, less(), l_combine
+                     , l_combine1, l_block, xbuf
+                     , n_block_a, n_block_b, l_irreg1, l_irreg2, true);   //Outputs
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combine: ", len);
+      BOOST_ASSERT(xbuf.size() >= l_block);
+      merge_blocks_with_buf
+         (uint_keys, less(), first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, xbuf.data(), true);
+      xbuf.clear();
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A mrg buf: ", len);
+   }
+}
+
+template<class RandIt, class Compare, class XBuf>
+inline void adaptive_merge_final_merge( RandIt first
+                                      , typename iterator_traits<RandIt>::size_type len1
+                                      , typename iterator_traits<RandIt>::size_type len2
+                                      , typename iterator_traits<RandIt>::size_type collected
+                                      , typename iterator_traits<RandIt>::size_type l_intbuf
+                                      , typename iterator_traits<RandIt>::size_type l_block
+                                      , bool use_internal_buf
+                                      , bool xbuf_used
+                                      , Compare comp
+                                      , XBuf & xbuf
+                                      )
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   (void)l_block;
+   size_type n_keys = collected-l_intbuf;
+   size_type len = len1+len2;
+   if(use_internal_buf){
+      if(xbuf_used){
+         xbuf.clear();
+         //Nothing to do
+         if(n_keys){
+            stable_sort(first, first+n_keys, comp, xbuf);
+            stable_merge(first, first+n_keys, first+len, comp, xbuf);
+            BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A key mrg: ", len);
+         }
+      }
+      else{
+         xbuf.clear();
+         stable_sort(first, first+collected, comp, xbuf);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
+         stable_merge(first, first+collected, first+len, comp, xbuf);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
+      }
+   }
+   else{
+      xbuf.clear();
+      stable_sort(first, first+collected, comp, xbuf);
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
+      stable_merge(first, first+collected, first+len1+len2, comp, xbuf);
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
+   }
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A fin mrg: ", len);
+}
+
+template<class SizeType, class Xbuf>
+inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1, SizeType len2, Xbuf & xbuf, SizeType &l_intbuf_inout)
+{
+   typedef SizeType size_type;
+   size_type l_block = rl_block;
+   size_type l_intbuf = xbuf.capacity() >= l_block ? 0u : l_block;
+
+   while(xbuf.capacity() >= l_block*2){
+      l_block *= 2;
+   }
+
+   //This is the minimum number of keys to implement the ideal algorithm
+   size_type n_keys = len1/l_block+len2/l_block;
+   while(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)){
+      --n_keys;
+   }
+   ++n_keys;
+   BOOST_ASSERT(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block));
+
+   if(xbuf.template supports_aligned_trailing<size_type>(l_block, n_keys)){
+      n_keys = 0u;
+   }
+   l_intbuf_inout = l_intbuf;
+   rl_block = l_block;
+   return n_keys;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////
+
+// Main explanation of the sort algorithm.
+//
+// csqrtlen = ceil(sqrt(len));
+//
+// * First, 2*csqrtlen unique elements elements are extracted from elements to be
+//   sorted and placed in the beginning of the range.
+//
+// * Step "build_blocks": In this nearly-classic merge step, 2*csqrtlen unique elements
+//   will be used as auxiliary memory, so trailing len-2*csqrtlen elements are
+//   are grouped in blocks of sorted 4*csqrtlen elements. At the end of the step
+//   2*csqrtlen unique elements are again the leading elements of the whole range.
+//
+// * Step "combine_blocks": pairs of previously formed blocks are merged with a different
+//   ("smart") algorithm to form blocks of 8*csqrtlen elements. This step is slower than the
+//   "build_blocks" step and repeated iteratively (forming blocks of 16*csqrtlen, 32*csqrtlen
+//   elements, etc) of until all trailing (len-2*csqrtlen) elements are merged.
+//
+//   In "combine_blocks" len/csqrtlen elements used are as "keys" (markers) to
+//   know if elements belong to the first or second block to be merged and another 
+//   leading csqrtlen elements are used as buffer. Explanation of the "combine_blocks" step:
+//
+//   Iteratively until all trailing (len-2*csqrtlen) elements are merged:
+//      Iteratively for each pair of previously merged block:
+//         * Blocks are divided groups of csqrtlen elements and
+//           2*merged_block/csqrtlen keys are sorted to be used as markers
+//         * Groups are selection-sorted by first or last element (depending whether they are going
+//           to be merged to left or right) and keys are reordered accordingly as an imitation-buffer.
+//         * Elements of each block pair are merged using the csqrtlen buffer taking into account
+//           if they belong to the first half or second half (marked by the key).
+//
+// * In the final merge step leading elements (2*csqrtlen) are sorted and merged with
+//   rotations with the rest of sorted elements in the "combine_blocks" step.
+//
+// Corner cases:
+//
+// * If no 2*csqrtlen elements can be extracted:
+//
+//    * If csqrtlen+len/csqrtlen are extracted, then only csqrtlen elements are used
+//      as buffer in the "build_blocks" step forming blocks of 2*csqrtlen elements. This
+//      means that an additional "combine_blocks" step will be needed to merge all elements.
+//    
+//    * If no csqrtlen+len/csqrtlen elements can be extracted, but still more than a minimum,
+//      then reduces the number of elements used as buffer and keys in the "build_blocks"
+//      and "combine_blocks" steps. If "combine_blocks" has no enough keys due to this reduction
+//      then uses a rotation based smart merge.
+//
+//    * If the minimum number of keys can't be extracted, a rotation-based sorting is performed.
+//
+// * If auxiliary memory is more or equal than ceil(len/2), half-copying mergesort is used.
+//
+// * If auxiliary memory is more than csqrtlen+n_keys*sizeof(std::size_t),
+//   then only csqrtlen elements need to be extracted and "combine_blocks" will use integral
+//   keys to combine blocks.
+//
+// * If auxiliary memory is available, the "build_blocks" will be extended to build bigger blocks
+//   using classic merge and "combine_blocks" will use bigger blocks when merging.
+template<class RandIt, class Compare, class XBuf>
+void adaptive_sort_impl
+   ( RandIt first
+   , typename iterator_traits<RandIt>::size_type const len
+   , Compare comp
+   , XBuf & xbuf
+   )
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+
+   //Small sorts go directly to insertion sort
+   if(len <= size_type(AdaptiveSortInsertionSortThreshold)){
+      insertion_sort(first, first + len, comp);
+   }
+   else if((len-len/2) <= xbuf.capacity()){
+      merge_sort(first, first+len, comp, xbuf.data());
+   }
+   else{
+      //Make sure it is at least four
+      BOOST_STATIC_ASSERT(AdaptiveSortInsertionSortThreshold >= 4);
+
+      size_type l_base = 0;
+      size_type l_intbuf = 0;
+      size_type n_keys = 0;
+      size_type l_build_buf = 0;
+
+      //Calculate and extract needed unique elements. If a minimum is not achieved
+      //fallback to a slow stable sort
+      if(!adaptive_sort_build_params(first, len, comp, n_keys, l_intbuf, l_base, l_build_buf, xbuf)){
+         stable_sort(first, first+len, comp, xbuf);
+      }
+      else{
+         BOOST_ASSERT(l_build_buf);
+         //Otherwise, continue the adaptive_sort
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("\n   After collect_unique: ", len);
+         size_type const n_key_plus_buf = l_intbuf+n_keys;
+         //l_build_buf is always power of two if l_intbuf is zero
+         BOOST_ASSERT(l_intbuf || (0 == (l_build_buf & (l_build_buf-1))));
+
+         //Classic merge sort until internal buffer and xbuf are exhausted
+         size_type const l_merged = adaptive_sort_build_blocks
+            (first+n_key_plus_buf-l_build_buf, len-n_key_plus_buf+l_build_buf, l_base, l_build_buf, xbuf, comp);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   After build_blocks:   ", len);
+
+         //Non-trivial merge
+         bool const buffer_right = adaptive_sort_combine_all_blocks
+            (first, n_keys, first+n_keys, len-n_keys, l_merged, l_intbuf, xbuf, comp);
+
+         //Sort keys and buffer and merge the whole sequence
+         adaptive_sort_final_merge(buffer_right, first, l_intbuf, n_keys, len, xbuf, comp);
+      }
+   }
+}
+
+// Main explanation of the merge algorithm.
+//
+// csqrtlen = ceil(sqrt(len));
+//
+// * First, csqrtlen [to be used as buffer] + (len/csqrtlen - 1) [to be used as keys] => to_collect
+//   unique elements are extracted from elements to be sorted and placed in the beginning of the range.
+//
+// * Step "combine_blocks": the leading (len1-to_collect) elements plus trailing len2 elements
+//   are merged with a non-trivial ("smart") algorithm to form an ordered range trailing "len-to_collect" elements.
+//
+//   Explanation of the "combine_blocks" step:
+//
+//         * Trailing [first+to_collect, first+len1) elements are divided in groups of cqrtlen elements.
+//           Remaining elements that can't form a group are grouped in front of those elements.
+//         * Trailing [first+len1, first+len1+len2) elements are divided in groups of cqrtlen elements.
+//           Remaining elements that can't form a group are grouped in the back of those elements.
+//         * In parallel the following two steps are performed:
+//             *  Groups are selection-sorted by first or last element (depending whether they are going
+//                to be merged to left or right) and keys are reordered accordingly as an imitation-buffer.
+//             * Elements of each block pair are merged using the csqrtlen buffer taking into account
+//                if they belong to the first half or second half (marked by the key).
+//
+// * In the final merge step leading "to_collect" elements are merged with rotations
+//   with the rest of merged elements in the "combine_blocks" step.
+//
+// Corner cases:
+//
+// * If no "to_collect" elements can be extracted:
+//
+//    * If more than a minimum number of elements is extracted
+//      then reduces the number of elements used as buffer and keys in the
+//      and "combine_blocks" steps. If "combine_blocks" has no enough keys due to this reduction
+//      then uses a rotation based smart merge.
+//
+//    * If the minimum number of keys can't be extracted, a rotation-based merge is performed.
+//
+// * If auxiliary memory is more or equal than min(len1, len2), a buffered merge is performed.
+//
+// * If the len1 or len2 are less than 2*csqrtlen then a rotation-based merge is performed.
+//
+// * If auxiliary memory is more than csqrtlen+n_keys*sizeof(std::size_t),
+//   then no csqrtlen need to be extracted and "combine_blocks" will use integral
+//   keys to combine blocks.
+template<class RandIt, class Compare, class XBuf>
+void adaptive_merge_impl
+   ( RandIt first
+   , typename iterator_traits<RandIt>::size_type const len1
+   , typename iterator_traits<RandIt>::size_type const len2
+   , Compare comp
+   , XBuf & xbuf
+   )
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+
+   if(xbuf.capacity() >= min_value<size_type>(len1, len2)){
+      buffered_merge(first, first+len1, first+(len1+len2), comp, xbuf);
+   }
+   else{
+      const size_type len = len1+len2;
+      //Calculate ideal parameters and try to collect needed unique keys
+      size_type l_block = size_type(ceil_sqrt(len));
+
+      //One range is not big enough to extract keys and the internal buffer so a
+      //rotation-based based merge will do just fine
+      if(len1 <= l_block*2 || len2 <= l_block*2){
+         merge_bufferless(first, first+len1, first+len1+len2, comp);
+         return;
+      }
+
+      //Detail the number of keys and internal buffer. If xbuf has enough memory, no
+      //internal buffer is needed so l_intbuf will remain 0.
+      size_type l_intbuf = 0;
+      size_type n_keys = adaptive_merge_n_keys_intbuf(l_block, len1, len2, xbuf, l_intbuf);
+      size_type const to_collect = l_intbuf+n_keys;
+      //Try to extract needed unique values from the first range
+      size_type const collected  = collect_unique(first, first+len1, to_collect, comp, xbuf);
+      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("\n   A collect: ", len);
+
+      //Not the minimum number of keys is not available on the first range, so fallback to rotations
+      if(collected != to_collect && collected < 4){
+         merge_bufferless(first, first+collected, first+len1, comp);
+         merge_bufferless(first, first + len1, first + len1 + len2, comp);
+         return;
+      }
+
+      //If not enough keys but more than minimum, adjust the internal buffer and key count
+      bool use_internal_buf = collected == to_collect;
+      if (!use_internal_buf){
+         l_intbuf = 0u;
+         n_keys = collected;
+         l_block  = lblock_for_combine(l_intbuf, n_keys, len, use_internal_buf);
+         //If use_internal_buf is false, then then internal buffer will be zero and rotation-based combination will be used
+         l_intbuf = use_internal_buf ? l_block : 0u;
+      }
+
+      bool const xbuf_used = collected == to_collect && xbuf.capacity() >= l_block;
+      //Merge trailing elements using smart merges
+      adaptive_merge_combine_blocks(first, len1, len2, collected,   n_keys, l_block, use_internal_buf, xbuf_used, comp, xbuf);
+      //Merge buffer and keys with the rest of the values
+      adaptive_merge_final_merge   (first, len1, len2, collected, l_intbuf, l_block, use_internal_buf, xbuf_used, comp, xbuf);
+   }
+}
+
+
+}  //namespace detail_adaptive {
+}  //namespace movelib {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif   //#define BOOST_MOVE_ADAPTIVE_SORT_MERGE_HPP
diff --git a/boost/move/algo/detail/basic_op.hpp b/boost/move/algo/detail/basic_op.hpp
new file mode 100644
index 0000000..ea5faf0
--- /dev/null
+++ b/boost/move/algo/detail/basic_op.hpp
@@ -0,0 +1,121 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_ALGO_BASIC_OP
+#define BOOST_MOVE_ALGO_BASIC_OP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+
+namespace boost {
+namespace movelib {
+
+struct forward_t{};
+struct backward_t{};
+struct three_way_t{};
+struct three_way_forward_t{};
+struct four_way_t{};
+
+struct move_op
+{
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   {  *dest = ::boost::move(*source);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return ::boost::move(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
+   {  return ::boost::move_backward(first, last, dest_last);  }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      //Destination2 range can overlap SourceIt range so avoid boost::move
+      while(srcit != srcitend){
+         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
+      }
+      return dest2it;
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   {
+      *dest3it = boost::move(*dest2it);
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+   }
+};
+
+struct swap_op
+{
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   {  boost::adl_move_swap(*dest, *source);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+      *srcit = boost::move(tmp);
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      while(srcit != srcitend){
+         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
+      }
+      return dest2it;
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   {
+      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
+      *dest3it = boost::move(*dest2it);
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+      *srcit = boost::move(tmp);
+   }
+};
+
+
+}} //namespace boost::movelib
+
+#endif   //BOOST_MOVE_ALGO_BASIC_OP
diff --git a/boost/move/algo/detail/insertion_sort.hpp b/boost/move/algo/detail/insertion_sort.hpp
new file mode 100644
index 0000000..3328f75
--- /dev/null
+++ b/boost/move/algo/detail/insertion_sort.hpp
@@ -0,0 +1,128 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_INSERT_SORT_HPP
+#define BOOST_MOVE_DETAIL_INSERT_SORT_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/utility_core.hpp>
+#include <boost/move/algo/move.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/destruct_n.hpp>
+#include <boost/move/algo/detail/basic_op.hpp>
+#include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
+
+namespace boost {  namespace movelib{
+
+// @cond
+
+template <class Compare, class ForwardIterator, class BirdirectionalIterator, class Op>
+void insertion_sort_op(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp, Op op)
+{
+   if (first1 != last1){
+      BirdirectionalIterator last2 = first2;
+      op(first1, last2);
+      for (++last2; ++first1 != last1; ++last2){
+         BirdirectionalIterator j2 = last2;
+         BirdirectionalIterator i2 = j2;
+         if (comp(*first1, *--i2)){
+            op(i2, j2);
+            for (--j2; i2 != first2 && comp(*first1, *--i2); --j2) {
+               op(i2, j2);
+            }
+         }
+         op(first1, j2);
+      }
+   }
+}
+
+template <class Compare, class ForwardIterator, class BirdirectionalIterator>
+void insertion_sort_swap(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp)
+{
+   insertion_sort_op(first1, last1, first2, comp, swap_op());
+}
+
+
+template <class Compare, class ForwardIterator, class BirdirectionalIterator>
+void insertion_sort_copy(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp)
+{
+   insertion_sort_op(first1, last1, first2, comp, move_op());
+}
+
+// @endcond
+
+template <class Compare, class BirdirectionalIterator>
+void insertion_sort(BirdirectionalIterator first, BirdirectionalIterator last, Compare comp)
+{
+   typedef typename boost::movelib::iterator_traits<BirdirectionalIterator>::value_type value_type;
+   if (first != last){
+      BirdirectionalIterator i = first;
+      for (++i; i != last; ++i){
+         BirdirectionalIterator j = i;
+         if (comp(*i,  *--j)) {
+            value_type tmp(::boost::move(*i));
+            *i = ::boost::move(*j);
+            for (BirdirectionalIterator k = j; k != first && comp(tmp,  *--k); --j) {
+               *j = ::boost::move(*k);
+            }
+            *j = ::boost::move(tmp);
+         }
+      }
+   }
+}
+
+template <class Compare, class BirdirectionalIterator, class BirdirectionalRawIterator>
+void insertion_sort_uninitialized_copy
+   (BirdirectionalIterator first1, BirdirectionalIterator const last1
+   , BirdirectionalRawIterator const first2
+   , Compare comp)
+{
+   typedef typename iterator_traits<BirdirectionalIterator>::value_type value_type;
+   if (first1 != last1){
+      BirdirectionalRawIterator last2 = first2;
+      ::new((iterator_to_raw_pointer)(last2), boost_move_new_t()) value_type(move(*first1));
+      destruct_n<value_type, BirdirectionalRawIterator> d(first2);
+      d.incr();
+      for (++last2; ++first1 != last1; ++last2){
+         BirdirectionalRawIterator j2 = last2;
+         BirdirectionalRawIterator k2 = j2;
+         if (comp(*first1, *--k2)){
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(move(*k2));
+            d.incr();
+            for (--j2; k2 != first2 && comp(*first1, *--k2); --j2)
+               *j2 = move(*k2);
+            *j2 = move(*first1);
+         }
+         else{
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(move(*first1));
+            d.incr();
+         }
+      }
+      d.release();
+   }
+}
+
+}} //namespace boost {  namespace movelib{
+
+#endif //#ifndef BOOST_MOVE_DETAIL_INSERT_SORT_HPP
diff --git a/boost/move/algo/detail/merge.hpp b/boost/move/algo/detail/merge.hpp
new file mode 100644
index 0000000..621dfa2
--- /dev/null
+++ b/boost/move/algo/detail/merge.hpp
@@ -0,0 +1,577 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_MERGE_HPP
+#define BOOST_MOVE_MERGE_HPP
+
+#include <boost/move/algo/move.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/detail/basic_op.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/destruct_n.hpp>
+#include <boost/move/algo/predicate.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace movelib {
+
+// @cond
+
+/*
+template<typename Unsigned>
+inline Unsigned gcd(Unsigned x, Unsigned y)
+{
+   if(0 == ((x &(x-1)) | (y & (y-1)))){
+      return x < y ? x : y;
+   }
+   else{
+      do
+      {
+         Unsigned t = x % y;
+         x = y;
+         y = t;
+      } while (y);
+      return x;
+   }
+}
+*/
+
+//Modified version from "An Optimal In-Place Array Rotation Algorithm", Ching-Kuang Shene
+template<typename Unsigned>
+Unsigned gcd(Unsigned x, Unsigned y)
+{
+   if(0 == ((x &(x-1)) | (y & (y-1)))){
+      return x < y ? x : y;
+   }
+   else{
+      Unsigned z = 1;
+      while((!(x&1)) & (!(y&1))){
+         z <<=1, x>>=1, y>>=1;
+      }
+      while(x && y){
+         if(!(x&1))
+            x >>=1;
+         else if(!(y&1))
+            y >>=1;
+         else if(x >=y)
+            x = (x-y) >> 1;
+         else
+            y = (y-x) >> 1;
+      }
+      return z*(x+y);
+   }
+}
+
+template<typename RandIt>
+RandIt rotate_gcd(RandIt first, RandIt middle, RandIt last)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+
+   if(first == middle)
+      return last;
+   if(middle == last)
+      return first;
+   const size_type middle_pos = size_type(middle - first);
+   RandIt ret = last - middle_pos;
+   if (middle == ret){
+      boost::adl_move_swap_ranges(first, middle, middle);
+   }
+   else{
+      const size_type length = size_type(last - first);
+      for( RandIt it_i(first), it_gcd(it_i + gcd(length, middle_pos))
+         ; it_i != it_gcd
+         ; ++it_i){
+         value_type temp(boost::move(*it_i));
+         RandIt it_j = it_i;
+         RandIt it_k = it_j+middle_pos;
+         do{
+            *it_j = boost::move(*it_k);
+            it_j = it_k;
+            size_type const left = size_type(last - it_j);
+            it_k = left > middle_pos ? it_j + middle_pos : first + (middle_pos - left);
+         } while(it_k != it_i);
+         *it_j = boost::move(temp);
+      }
+   }
+   return ret;
+}
+
+template <class RandIt, class T, class Compare>
+RandIt lower_bound
+   (RandIt first, const RandIt last, const T& key, Compare comp)
+{
+   typedef typename iterator_traits
+      <RandIt>::size_type size_type;
+   size_type len = size_type(last - first);
+   RandIt middle;
+
+   while (len) {
+      size_type step = len >> 1;
+      middle = first;
+      middle += step;
+
+      if (comp(*middle, key)) {
+         first = ++middle;
+         len -= step + 1;
+      }
+      else{
+         len = step;
+      }
+   }
+   return first;
+}
+
+template <class RandIt, class T, class Compare>
+RandIt upper_bound
+   (RandIt first, const RandIt last, const T& key, Compare comp)
+{
+   typedef typename iterator_traits
+      <RandIt>::size_type size_type;
+   size_type len = size_type(last - first);
+   RandIt middle;
+
+   while (len) {
+      size_type step = len >> 1;
+      middle = first;
+      middle += step;
+
+      if (!comp(key, *middle)) {
+         first = ++middle;
+         len -= step + 1;
+      }
+      else{
+         len = step;
+      }
+   }
+   return first;
+}
+
+
+template<class RandIt, class Compare, class Op>
+void op_merge_left( RandIt buf_first
+                    , RandIt first1
+                    , RandIt const last1
+                    , RandIt const last2
+                    , Compare comp
+                    , Op op)
+{
+   for(RandIt first2=last1; first2 != last2; ++buf_first){
+      if(first1 == last1){
+         op(forward_t(), first2, last2, buf_first);
+         return;
+      }
+      else if(comp(*first2, *first1)){
+         op(first2, buf_first);
+         ++first2;
+      }
+      else{
+         op(first1, buf_first);
+         ++first1;
+      }
+   }
+   if(buf_first != first1){//In case all remaining elements are in the same place
+                           //(e.g. buffer is exactly the size of the second half
+                           //and all elements from the second half are less)
+      op(forward_t(), first1, last1, buf_first);
+   }
+}
+
+// [buf_first, first1) -> buffer
+// [first1, last1) merge [last1,last2) -> [buf_first,buf_first+(last2-first1))
+// Elements from buffer are moved to [last2 - (first1-buf_first), last2)
+// Note: distance(buf_first, first1) >= distance(last1, last2), so no overlapping occurs
+template<class RandIt, class Compare>
+void merge_left
+   (RandIt buf_first, RandIt first1, RandIt const last1, RandIt const last2, Compare comp)
+{
+   op_merge_left(buf_first, first1, last1, last2, comp, move_op());
+}
+
+// [buf_first, first1) -> buffer
+// [first1, last1) merge [last1,last2) -> [buf_first,buf_first+(last2-first1))
+// Elements from buffer are swapped to [last2 - (first1-buf_first), last2)
+// Note: distance(buf_first, first1) >= distance(last1, last2), so no overlapping occurs
+template<class RandIt, class Compare>
+void swap_merge_left
+   (RandIt buf_first, RandIt first1, RandIt const last1, RandIt const last2, Compare comp)
+{
+   op_merge_left(buf_first, first1, last1, last2, comp, swap_op());
+}
+
+template<class RandIt, class Compare, class Op>
+void op_merge_right
+   (RandIt const first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp, Op op)
+{
+   RandIt const first2 = last1;
+   while(first1 != last1){
+      if(last2 == first2){
+         op(backward_t(), first1, last1, buf_last);
+         return;
+      }
+      --last2;
+      --last1;
+      --buf_last;
+      if(comp(*last2, *last1)){
+         op(last1, buf_last);
+         ++last2;
+      }
+      else{
+         op(last2, buf_last);
+         ++last1;
+      }
+   }
+   if(last2 != buf_last){  //In case all remaining elements are in the same place
+                           //(e.g. buffer is exactly the size of the first half
+                           //and all elements from the second half are less)
+      op(backward_t(), first2, last2, buf_last);
+   }
+}
+
+// [last2, buf_last) - buffer
+// [first1, last1) merge [last1,last2) -> [first1+(buf_last-last2), buf_last)
+// Note: distance[last2, buf_last) >= distance[first1, last1), so no overlapping occurs
+template<class RandIt, class Compare>
+void merge_right
+   (RandIt first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp)
+{
+   op_merge_right(first1, last1, last2, buf_last, comp, move_op());
+}
+
+// [last2, buf_last) - buffer
+// [first1, last1) merge [last1,last2) -> [first1+(buf_last-last2), buf_last)
+// Note: distance[last2, buf_last) >= distance[first1, last1), so no overlapping occurs
+template<class RandIt, class Compare>
+void swap_merge_right
+   (RandIt first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp)
+{
+   op_merge_right(first1, last1, last2, buf_last, comp, swap_op());
+}
+
+template <class BidirIt, class Distance, class Compare>
+void merge_bufferless_ONlogN_recursive
+   (BidirIt first, BidirIt middle, BidirIt last, Distance len1, Distance len2, Compare comp)
+{
+   typedef typename iterator_traits<BidirIt>::size_type size_type;
+   while(1) {
+      //#define MERGE_BUFFERLESS_RECURSIVE_OPT
+      #ifndef MERGE_BUFFERLESS_RECURSIVE_OPT
+      if (len2  == 0) {
+         return;
+      }
+
+      if (!len1) {
+         return;
+      }
+
+      if ((len1 | len2) == 1) {
+         if (comp(*middle, *first))
+            adl_move_swap(*first, *middle);  
+         return;
+      }
+      #else
+      if (len2  == 0) {
+         return;
+      }
+
+      if (!len1) {
+         return;
+      }
+      BidirIt middle_prev = middle; --middle_prev;
+      if(!comp(*middle, *middle_prev))
+         return;
+
+      while(true) {
+         if (comp(*middle, *first))
+            break;
+         ++first;
+         if(--len1 == 1)
+            break;
+      }
+
+      if (len1 == 1 && len2 == 1) {
+         //comp(*middle, *first) == true already tested in the loop
+         adl_move_swap(*first, *middle);  
+         return;
+      }
+      #endif
+
+      BidirIt first_cut = first;
+      BidirIt second_cut = middle;
+      Distance len11 = 0;
+      Distance len22 = 0;
+      if (len1 > len2) {
+         len11 = len1 / 2;
+         first_cut +=  len11;
+         second_cut = boost::movelib::lower_bound(middle, last, *first_cut, comp);
+         len22 = size_type(second_cut - middle);
+      }
+      else {
+         len22 = len2 / 2;
+         second_cut += len22;
+         first_cut = boost::movelib::upper_bound(first, middle, *second_cut, comp);
+         len11 = size_type(first_cut - first);
+      }
+      BidirIt new_middle = rotate_gcd(first_cut, middle, second_cut);
+
+      //Avoid one recursive call doing a manual tail call elimination on the biggest range
+      const Distance len_internal = len11+len22;
+      if( len_internal < (len1 + len2 - len_internal) ) {
+         merge_bufferless_ONlogN_recursive(first,      first_cut,  new_middle, len11,        len22,        comp);
+         //merge_bufferless_recursive(new_middle, second_cut, last,       len1 - len11, len2 - len22, comp);
+         first = new_middle;
+         middle = second_cut;
+         len1 -= len11;
+         len2 -= len22;
+      }
+      else {
+         //merge_bufferless_recursive(first,      first_cut,  new_middle, len11,        len22,        comp);
+         merge_bufferless_ONlogN_recursive(new_middle, second_cut, last,       len1 - len11, len2 - len22, comp);
+         middle = first_cut;
+         last = new_middle;
+         len1 = len11;
+         len2 = len22;
+      }
+   }
+}
+
+//Complexity: NlogN
+template<class BidirIt, class Compare>
+void merge_bufferless_ONlogN(BidirIt first, BidirIt middle, BidirIt last, Compare comp)
+{
+   merge_bufferless_ONlogN_recursive
+      (first, middle, last, middle - first, last - middle, comp); 
+}
+
+//Complexity: min(len1,len2)^2 + max(len1,len2)
+template<class RandIt, class Compare>
+void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp)
+{
+   if((middle - first) < (last - middle)){
+      while(first != middle){
+         RandIt const old_last1 = middle;
+         middle = boost::movelib::lower_bound(middle, last, *first, comp);
+         first = rotate_gcd(first, old_last1, middle);
+         if(middle == last){
+            break;
+         }
+         do{
+            ++first;
+         } while(first != middle && !comp(*middle, *first));
+      }
+   }
+   else{
+      while(middle != last){
+         RandIt p = boost::movelib::upper_bound(first, middle, last[-1], comp);
+         last = rotate_gcd(p, middle, last);
+         middle = p;
+         if(middle == first){
+            break;
+         }
+         --p;
+         do{
+            --last;
+         } while(middle != last && !comp(last[-1], *p));
+      }
+   }
+}
+
+template<class RandIt, class Compare>
+void merge_bufferless(RandIt first, RandIt middle, RandIt last, Compare comp)
+{
+   //#define BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
+   #ifdef BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
+   merge_bufferless_ONlogN(first, middle, last, comp);
+   #else
+   merge_bufferless_ON2(first, middle, last, comp);
+   #endif   //BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
+}
+
+// [r_first, r_last) are already in the right part of the destination range.
+template <class Compare, class InputIterator, class InputOutIterator, class Op>
+void op_merge_with_right_placed
+   ( InputIterator first, InputIterator last
+   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
+   , Compare comp, Op op)
+{
+   BOOST_ASSERT((last - first) == (r_first - dest_first));
+   while ( first != last ) {
+      if (r_first == r_last) {
+         InputOutIterator end = op(forward_t(), first, last, dest_first);
+         BOOST_ASSERT(end == r_last);
+         (void)end;
+         return;
+      }
+      else if (comp(*r_first, *first)) {
+         op(r_first, dest_first);
+         ++r_first;
+      }
+      else {
+         op(first, dest_first);
+         ++first;
+      }
+      ++dest_first;
+   }
+   // Remaining [r_first, r_last) already in the correct place
+}
+
+template <class Compare, class InputIterator, class InputOutIterator>
+void swap_merge_with_right_placed
+   ( InputIterator first, InputIterator last
+   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
+   , Compare comp)
+{
+   op_merge_with_right_placed(first, last, dest_first, r_first, r_last, comp, swap_op());
+}
+
+// [first, last) are already in the right part of the destination range.
+template <class Compare, class Op, class BidirIterator, class BidirOutIterator>
+void op_merge_with_left_placed
+   ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
+   , BidirIterator const r_first, BidirIterator r_last
+   , Compare comp, Op op)
+{
+   BOOST_ASSERT((dest_last - last) == (r_last - r_first));
+   while( r_first != r_last ) {
+      if(first == last) {
+         BidirOutIterator res = op(backward_t(), r_first, r_last, dest_last);
+         BOOST_ASSERT(last == res);
+         (void)res;
+         return;
+      }
+      --r_last;
+      --last;
+      if(comp(*r_last, *last)){
+         ++r_last;
+         --dest_last;
+         op(last, dest_last);
+      }
+      else{
+         ++last;
+         --dest_last;
+         op(r_last, dest_last);
+      }
+   }
+   // Remaining [first, last) already in the correct place
+}
+
+// @endcond
+
+// [irst, last) are already in the right part of the destination range.
+template <class Compare, class BidirIterator, class BidirOutIterator>
+void merge_with_left_placed
+   ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
+   , BidirIterator const r_first, BidirIterator r_last
+   , Compare comp)
+{
+   op_merge_with_left_placed(first, last, dest_last, r_first, r_last, comp, move_op());
+}
+
+// [r_first, r_last) are already in the right part of the destination range.
+template <class Compare, class InputIterator, class InputOutIterator>
+void merge_with_right_placed
+   ( InputIterator first, InputIterator last
+   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
+   , Compare comp)
+{
+   op_merge_with_right_placed(first, last, dest_first, r_first, r_last, comp, move_op());
+}
+
+// [r_first, r_last) are already in the right part of the destination range.
+// [dest_first, r_first) is uninitialized memory
+template <class Compare, class InputIterator, class InputOutIterator>
+void uninitialized_merge_with_right_placed
+   ( InputIterator first, InputIterator last
+   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
+   , Compare comp)
+{
+   BOOST_ASSERT((last - first) == (r_first - dest_first));
+   typedef typename iterator_traits<InputOutIterator>::value_type value_type;
+   InputOutIterator const original_r_first = r_first;
+
+   destruct_n<value_type, InputOutIterator> d(dest_first);
+
+   while ( first != last && dest_first != original_r_first ) {
+      if (r_first == r_last) {
+         for(; dest_first != original_r_first; ++dest_first, ++first){
+            ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
+            d.incr();
+         }
+         d.release();
+         InputOutIterator end = ::boost::move(first, last, original_r_first);
+         BOOST_ASSERT(end == r_last);
+         (void)end;
+         return;
+      }
+      else if (comp(*r_first, *first)) {
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*r_first));
+         d.incr();
+         ++r_first;
+      }
+      else {
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
+         d.incr();
+         ++first;
+      }
+      ++dest_first;
+   }
+   d.release();
+   merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
+}
+
+/*
+// [r_first, r_last) are already in the right part of the destination range.
+// [dest_first, r_first) is uninitialized memory
+template <class Compare, class BidirOutIterator, class BidirIterator>
+void uninitialized_merge_with_left_placed
+   ( BidirOutIterator dest_first, BidirOutIterator r_first, BidirOutIterator r_last
+   , BidirIterator first, BidirIterator last
+   , Compare comp)
+{
+   BOOST_ASSERT((last - first) == (r_last - r_first));
+   typedef typename iterator_traits<BidirOutIterator>::value_type value_type;
+   BidirOutIterator const original_r_last = r_last;
+
+   destruct_n<value_type> d(&*dest_last);
+
+   while ( first != last && dest_first != original_r_first ) {
+      if (r_first == r_last) {
+         for(; dest_first != original_r_first; ++dest_first, ++first){
+            ::new(&*dest_first) value_type(::boost::move(*first));
+            d.incr();
+         }
+         d.release();
+         BidirOutIterator end = ::boost::move(first, last, original_r_first);
+         BOOST_ASSERT(end == r_last);
+         (void)end;
+         return;
+      }
+      else if (comp(*r_first, *first)) {
+         ::new(&*dest_first) value_type(::boost::move(*r_first));
+         d.incr();
+         ++r_first;
+      }
+      else {
+         ::new(&*dest_first) value_type(::boost::move(*first));
+         d.incr();
+         ++first;
+      }
+      ++dest_first;
+   }
+   d.release();
+   merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
+}
+*/
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif   //#define BOOST_MOVE_MERGE_HPP
diff --git a/boost/move/algo/detail/merge_sort.hpp b/boost/move/algo/detail/merge_sort.hpp
new file mode 100644
index 0000000..62d185a
--- /dev/null
+++ b/boost/move/algo/detail/merge_sort.hpp
@@ -0,0 +1,139 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_MERGE_SORT_HPP
+#define BOOST_MOVE_DETAIL_MERGE_SORT_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/move/algo/move.hpp>
+#include <boost/move/algo/detail/merge.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/detail/destruct_n.hpp>
+#include <boost/move/algo/detail/insertion_sort.hpp>
+#include <cassert>
+
+namespace boost {
+namespace movelib {
+
+// @cond
+
+static const unsigned MergeSortInsertionSortThreshold = 16;
+
+template <class RandIt, class Compare>
+void inplace_stable_sort(RandIt first, RandIt last, Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   if (size_type(last - first) <= size_type(MergeSortInsertionSortThreshold)) {
+      insertion_sort(first, last, comp);
+      return;
+   }
+   RandIt middle = first + (last - first) / 2;
+   inplace_stable_sort(first, middle, comp);
+   inplace_stable_sort(middle, last, comp);
+   merge_bufferless_ONlogN_recursive
+      (first, middle, last, size_type(middle - first), size_type(last - middle), comp);
+}
+
+// @endcond
+
+template<class RandIt, class RandIt2, class Compare>
+void merge_sort_copy( RandIt first, RandIt last
+                   , RandIt2 dest, Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+
+   size_type const count = size_type(last - first);
+   if(count <= MergeSortInsertionSortThreshold){
+      insertion_sort_copy(first, last, dest, comp);
+   }
+   else{
+      size_type const half = count/2;
+      merge_sort_copy(first + half, last        , dest+half   , comp);
+      merge_sort_copy(first       , first + half, first + half, comp);
+      merge_with_right_placed
+         ( first + half, first + half + half
+         , dest, dest+half, dest + count
+         , comp);
+   }
+}
+
+template<class RandIt, class RandItRaw, class Compare>
+void merge_sort_uninitialized_copy( RandIt first, RandIt last
+                                 , RandItRaw uninitialized
+                                 , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+
+   size_type const count = size_type(last - first);
+   if(count <= MergeSortInsertionSortThreshold){
+      insertion_sort_uninitialized_copy(first, last, uninitialized, comp);
+   }
+   else{
+      size_type const half = count/2;
+      merge_sort_uninitialized_copy(first + half, last, uninitialized + half, comp);
+      destruct_n<value_type, RandItRaw> d(uninitialized+half);
+      d.incr(count-half);
+      merge_sort_copy(first, first + half, first + half, comp);
+      uninitialized_merge_with_right_placed
+         ( first + half, first + half + half
+         , uninitialized, uninitialized+half, uninitialized+count
+         , comp);
+      d.release();
+   }
+}
+
+template<class RandIt, class RandItRaw, class Compare>
+void merge_sort( RandIt first, RandIt last, Compare comp
+               , RandItRaw uninitialized)
+{
+   typedef typename iterator_traits<RandIt>::size_type  size_type;
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+
+   size_type const count = size_type(last - first);
+   if(count <= MergeSortInsertionSortThreshold){
+      insertion_sort(first, last, comp);
+   }
+   else{
+      size_type const half = count/2;
+      size_type const rest = count -  half;
+      RandIt const half_it = first + half;
+      RandIt const rest_it = first + rest;
+
+      merge_sort_uninitialized_copy(half_it, last, uninitialized, comp);
+      destruct_n<value_type, RandItRaw> d(uninitialized);
+      d.incr(rest);
+      merge_sort_copy(first, half_it, rest_it, comp);
+      merge_with_right_placed
+         ( uninitialized, uninitialized + rest
+         , first, rest_it, last, antistable<Compare>(comp));
+   }
+}
+
+}} //namespace boost {  namespace movelib{
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_MOVE_DETAIL_MERGE_SORT_HPP
diff --git a/boost/move/algo/move.hpp b/boost/move/algo/move.hpp
index d35f04a..2390877 100644
--- a/boost/move/algo/move.hpp
+++ b/boost/move/algo/move.hpp
@@ -26,6 +26,7 @@
 
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/detail/no_exceptions_support.hpp>
 
 namespace boost {
@@ -126,7 +127,7 @@ F uninitialized_move(I f, I l, F r
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         back->~input_value_type();
+         boost::movelib::iterator_to_raw_pointer(back)->~input_value_type();
       }
       BOOST_RETHROW;
    }
diff --git a/boost/move/algo/predicate.hpp b/boost/move/algo/predicate.hpp
new file mode 100644
index 0000000..0287d66
--- /dev/null
+++ b/boost/move/algo/predicate.hpp
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_ALGO_PREDICATE_HPP
+#define BOOST_MOVE_ALGO_PREDICATE_HPP
+
+#include <boost/move/algo/move.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/detail/basic_op.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/destruct_n.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace movelib {
+
+template<class Comp>
+struct antistable
+{
+   explicit antistable(Comp &comp)
+      : m_comp(comp)
+   {}
+
+   template<class U, class V>
+   bool operator()(const U &u, const V & v)
+   {  return !m_comp(v, u);  }
+
+   private:
+   antistable & operator=(const antistable &);
+   Comp &m_comp;
+};
+
+template <class Comp>
+class negate
+{
+   public:
+   negate()
+   {}
+
+   explicit negate(Comp comp)
+      : m_comp(comp)
+   {}
+
+   template <class T1, class T2>
+   bool operator()(const T1& l, const T2& r)
+   {
+      return !m_comp(l, r);
+   }
+
+   private:
+   Comp m_comp;
+};
+
+
+template <class Comp>
+class inverse
+{
+   public:
+   inverse()
+   {}
+
+   explicit inverse(Comp comp)
+      : m_comp(comp)
+   {}
+
+   template <class T1, class T2>
+   bool operator()(const T1& l, const T2& r)
+   {
+      return m_comp(r, l);
+   }
+
+   private:
+   Comp m_comp;
+};
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif   //#define BOOST_MOVE_ALGO_PREDICATE_HPP
diff --git a/boost/move/algo/unique.hpp b/boost/move/algo/unique.hpp
new file mode 100644
index 0000000..8022a65
--- /dev/null
+++ b/boost/move/algo/unique.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_ALGO_UNIQUE_HPP
+#define BOOST_MOVE_ALGO_UNIQUE_HPP
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost {
+namespace movelib {
+
+//! <b>Requires</b>: The comparison function shall be an equivalence relation. The type of *first shall satisfy
+//! the MoveAssignable requirements
+//!
+//! <b>Effects</b>: For a nonempty range, eliminates all but the first element from every consecutive group
+//!   of equivalent elements referred to by the iterator i in the range [first + 1, last) for which the
+//!   following conditions hold: pred(*(i - 1), *i) != false.
+//!
+//! <b>Returns</b>: The end of the resulting range.
+//!
+//! <b>Complexity</b>: For nonempty ranges, exactly (last - first) - 1 applications of the corresponding predicate.
+template<class ForwardIterator, class BinaryPredicate>
+ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+{
+    if (first != last) {
+      ForwardIterator next(first);
+      ++next;
+      for (; next != last; ++next, ++first) {
+         if (pred(*first, *next)) { //Find first equal element
+            while (++next != last)
+               if (!pred(*first, *next))
+                  *++first = ::boost::move(*next);
+            break;
+         }
+      }
+      ++first;
+   }
+   return first;
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif   //#define BOOST_MOVE_ALGO_UNIQUE_HPP
diff --git a/boost/move/core.hpp b/boost/move/core.hpp
index 1dd8a8c..db24ccf 100644
--- a/boost/move/core.hpp
+++ b/boost/move/core.hpp
@@ -64,15 +64,7 @@
    #endif
 
    //Move emulation rv breaks standard aliasing rules so add workarounds for some compilers
-   #if defined(__GNUC__) && (__GNUC__ >= 4) && \
-      (\
-         defined(BOOST_GCC) ||   \
-         (defined(BOOST_INTEL) && (BOOST_INTEL_CXX_VERSION >= 1300)) \
-      )
-      #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS __attribute__((__may_alias__))
-   #else
-      #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS
-   #endif
+   #define BOOST_MOVE_ATTRIBUTE_MAY_ALIAS BOOST_MAY_ALIAS
 
    namespace boost {
 
diff --git a/boost/move/detail/destruct_n.hpp b/boost/move/detail/destruct_n.hpp
new file mode 100644
index 0000000..9f60fc2
--- /dev/null
+++ b/boost/move/detail/destruct_n.hpp
@@ -0,0 +1,66 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+//! \file
+
+#ifndef BOOST_MOVE_DETAIL_DESTRUCT_N_HPP
+#define BOOST_MOVE_DETAIL_DESTRUCT_N_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <cstddef>
+
+namespace boost {
+namespace movelib{
+
+template<class T, class RandItUninit>
+class destruct_n
+{
+   public:
+   explicit destruct_n(RandItUninit raw)
+      : m_ptr(raw), m_size()
+   {}
+
+   void incr()
+   {
+      ++m_size;
+   }
+
+   void incr(std::size_t n)
+   {
+      m_size += n;
+   }
+
+   void release()
+   {
+      m_size = 0u;
+   }
+
+   ~destruct_n()
+   {
+      while(m_size--){
+         m_ptr[m_size].~T();
+      }
+   }
+   private:
+   RandItUninit m_ptr;
+   std::size_t m_size;
+};
+
+}} //namespace boost {  namespace movelib{
+
+#endif //#ifndef BOOST_MOVE_DETAIL_DESTRUCT_N_HPP
diff --git a/boost/move/detail/fwd_macros.hpp b/boost/move/detail/fwd_macros.hpp
index 7132436..a5df5f1 100644
--- a/boost/move/detail/fwd_macros.hpp
+++ b/boost/move/detail/fwd_macros.hpp
@@ -458,6 +458,31 @@ namespace move_detail {
 #define BOOST_MOVE_CLASSDFLTQ8 BOOST_MOVE_CLASSDFLTQ7, class Q7 = void
 #define BOOST_MOVE_CLASSDFLTQ9 BOOST_MOVE_CLASSDFLTQ8, class Q8 = void
 
+//BOOST_MOVE_LAST_TARGN
+#define BOOST_MOVE_LAST_TARG0 void
+#define BOOST_MOVE_LAST_TARG1 P0
+#define BOOST_MOVE_LAST_TARG2 P1
+#define BOOST_MOVE_LAST_TARG3 P2
+#define BOOST_MOVE_LAST_TARG4 P3
+#define BOOST_MOVE_LAST_TARG5 P4
+#define BOOST_MOVE_LAST_TARG6 P5
+#define BOOST_MOVE_LAST_TARG7 P6
+#define BOOST_MOVE_LAST_TARG8 P7
+#define BOOST_MOVE_LAST_TARG9 P8
+
+//BOOST_MOVE_LAST_TARGQN
+#define BOOST_MOVE_LAST_TARGQ0 void
+#define BOOST_MOVE_LAST_TARGQ1 Q0
+#define BOOST_MOVE_LAST_TARGQ2 Q1
+#define BOOST_MOVE_LAST_TARGQ3 Q2
+#define BOOST_MOVE_LAST_TARGQ4 Q3
+#define BOOST_MOVE_LAST_TARGQ5 Q4
+#define BOOST_MOVE_LAST_TARGQ6 Q5
+#define BOOST_MOVE_LAST_TARGQ7 Q6
+#define BOOST_MOVE_LAST_TARGQ8 Q7
+#define BOOST_MOVE_LAST_TARGQ9 Q8
+
+
 //BOOST_MOVE_TARGN
 #define BOOST_MOVE_TARG0
 #define BOOST_MOVE_TARG1                   P0
diff --git a/boost/move/detail/iterator_to_raw_pointer.hpp b/boost/move/detail/iterator_to_raw_pointer.hpp
new file mode 100644
index 0000000..97ee3a6
--- /dev/null
+++ b/boost/move/detail/iterator_to_raw_pointer.hpp
@@ -0,0 +1,59 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+#define BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/pointer_element.hpp>
+
+namespace boost {
+namespace movelib {
+namespace detail {
+
+template <class T>
+inline T* iterator_to_pointer(T* i)
+{  return i; }
+
+template <class Iterator>
+inline typename boost::movelib::iterator_traits<Iterator>::pointer
+   iterator_to_pointer(const Iterator &i)
+{  return i.operator->();  }
+
+template <class Iterator>
+struct iterator_to_element_ptr
+{
+   typedef typename boost::movelib::iterator_traits<Iterator>::pointer  pointer;
+   typedef typename boost::movelib::pointer_element<pointer>::type      element_type;
+   typedef element_type* type;
+};
+
+}  //namespace detail {
+
+template <class Iterator>
+inline typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
+   iterator_to_raw_pointer(const Iterator &i)
+{
+   return ::boost::movelib::to_raw_pointer
+      (  ::boost::movelib::detail::iterator_to_pointer(i)   );
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
diff --git a/boost/move/detail/placement_new.hpp b/boost/move/detail/placement_new.hpp
new file mode 100644
index 0000000..69d3332
--- /dev/null
+++ b/boost/move/detail/placement_new.hpp
@@ -0,0 +1,30 @@
+#ifndef BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP
+#define BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+struct boost_move_new_t{};
+
+//avoid including <new>
+inline void *operator new(std::size_t, void *p, boost_move_new_t)
+{  return p;  }
+
+inline void operator delete(void *, void *, boost_move_new_t)
+{}
+
+#endif   //BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP
diff --git a/boost/move/detail/pointer_element.hpp b/boost/move/detail/pointer_element.hpp
new file mode 100644
index 0000000..ecdd608
--- /dev/null
+++ b/boost/move/detail/pointer_element.hpp
@@ -0,0 +1,168 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP
+#define BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+#include <boost/move/detail/workaround.hpp>
+#endif   //BOOST_MOVE_DETAIL_WORKAROUND_HPP
+
+namespace boost {
+namespace movelib {
+namespace detail{
+
+//////////////////////
+//struct first_param
+//////////////////////
+
+template <typename T> struct first_param
+{  typedef void type;   };
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   template <template <typename, typename...> class TemplateClass, typename T, typename... Args>
+   struct first_param< TemplateClass<T, Args...> >
+   {
+      typedef T type;
+   };
+
+#else //C++03 compilers
+
+   template < template  //0arg
+               <class
+               > class TemplateClass, class T
+            >
+   struct first_param
+      < TemplateClass<T> >
+   {  typedef T type;   };
+
+   template < template  //1arg
+               <class,class
+               > class TemplateClass, class T
+            , class P0>
+   struct first_param
+      < TemplateClass<T, P0> >
+   {  typedef T type;   };
+
+   template < template  //2arg
+               <class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1>
+   struct first_param
+      < TemplateClass<T, P0, P1> >
+   {  typedef T type;   };
+
+   template < template  //3arg
+               <class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2> >
+   {  typedef T type;   };
+
+   template < template  //4arg
+               <class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3> >
+   {  typedef T type;   };
+
+   template < template  //5arg
+               <class,class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3, class P4>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3, P4> >
+   {  typedef T type;   };
+
+   template < template  //6arg
+               <class,class,class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3, class P4, class P5>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3, P4, P5> >
+   {  typedef T type;   };
+
+   template < template  //7arg
+               <class,class,class,class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3, class P4, class P5, class P6>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6> >
+   {  typedef T type;   };
+
+   template < template  //8arg
+               <class,class,class,class,class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7> >
+   {  typedef T type;   };
+
+   template < template  //9arg
+               <class,class,class,class,class,class,class,class,class,class
+               > class TemplateClass, class T
+            , class P0, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>
+   struct first_param
+      < TemplateClass<T, P0, P1, P2, P3, P4, P5, P6, P7, P8> >
+   {  typedef T type;   };
+
+#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename T>
+struct has_internal_pointer_element
+{
+   template <typename X>
+   static char test(int, typename X::element_type*);
+
+   template <typename X>
+   static int test(...);
+
+   static const bool value = (1 == sizeof(test<T>(0, 0)));
+};
+
+template<class Ptr, bool = has_internal_pointer_element<Ptr>::value>
+struct pointer_element_impl
+{
+   typedef typename Ptr::element_type type;
+};
+
+template<class Ptr>
+struct pointer_element_impl<Ptr, false>
+{
+   typedef typename boost::movelib::detail::first_param<Ptr>::type type;
+};
+
+}  //namespace detail{
+
+template <typename Ptr>
+struct pointer_element
+{
+   typedef typename ::boost::movelib::detail::pointer_element_impl<Ptr>::type type;
+};
+
+template <typename T>
+struct pointer_element<T*>
+{  typedef T type; };
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif // defined(BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP)
diff --git a/boost/move/detail/reverse_iterator.hpp b/boost/move/detail/reverse_iterator.hpp
new file mode 100644
index 0000000..73f59ce
--- /dev/null
+++ b/boost/move/detail/reverse_iterator.hpp
@@ -0,0 +1,171 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2014-2014
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP
+#define BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/meta_utils.hpp>
+
+namespace boost {
+namespace movelib {
+
+template<class It>
+class reverse_iterator
+{
+   public:
+   typedef typename boost::movelib::iterator_traits<It>::pointer             pointer;
+   typedef typename boost::movelib::iterator_traits<It>::reference           reference;
+   typedef typename boost::movelib::iterator_traits<It>::difference_type     difference_type;
+   typedef typename boost::movelib::iterator_traits<It>::iterator_category   iterator_category;
+   typedef typename boost::movelib::iterator_traits<It>::value_type          value_type;
+
+
+   typedef It iterator_type;
+
+   reverse_iterator()
+      : m_current()  //Value initialization to achieve "null iterators" (N3644)
+   {}
+
+   explicit reverse_iterator(It r)
+      : m_current(r)
+   {}
+
+   reverse_iterator(const reverse_iterator& r)
+      : m_current(r.base())
+   {}
+
+   template<class OtherIt>
+   reverse_iterator( const reverse_iterator<OtherIt>& r
+                   , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
+                   )
+      : m_current(r.base())
+   {}
+
+   reverse_iterator & operator=( const reverse_iterator& r)
+   {  m_current = r.base();   return *this;  }
+
+   template<class OtherIt>
+   typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+         operator=( const reverse_iterator<OtherIt>& r)
+   {  m_current = r.base();   return *this;  }
+
+   It base() const
+   {  return m_current;  }
+
+   reference operator*() const
+   {
+      It temp(m_current);
+      --temp;
+      reference r = *temp;
+      return r;
+   }
+
+   pointer operator->() const
+   {
+      It temp(m_current);
+      --temp;
+      return iterator_arrow_result(temp);
+   }
+
+   reference operator[](difference_type off) const
+   {
+      return this->m_current[-off - 1];
+   }
+
+   reverse_iterator& operator++()
+   {
+      --m_current;
+      return *this;
+   }
+
+   reverse_iterator operator++(int)
+   {
+      reverse_iterator temp((*this));
+      --m_current;
+      return temp;
+   }
+
+   reverse_iterator& operator--()
+   {
+      ++m_current;
+      return *this;
+   }
+
+   reverse_iterator operator--(int)
+   {
+      reverse_iterator temp((*this));
+      ++m_current;
+      return temp;
+   }
+
+   friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current == r.m_current;  }
+
+   friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current != r.m_current;  }
+
+   friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current > r.m_current;  }
+
+   friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current >= r.m_current;  }
+
+   friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current < r.m_current;  }
+
+   friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+   {  return l.m_current <= r.m_current;  }
+
+   reverse_iterator& operator+=(difference_type off)
+   {  m_current -= off; return *this;  }
+
+   reverse_iterator& operator-=(difference_type off)
+   {  m_current += off; return *this;  }
+
+   friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+   {  return (l += off);  }
+
+   friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+   {  return (r += off);   }
+
+   friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+   {  return (l-= off);  }
+
+   friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+   {  return r.m_current - l.m_current;  }
+
+   private:
+   It m_current;   // the wrapped iterator
+};
+
+template< class Iterator >
+reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
+{
+    return reverse_iterator<Iterator>(i);
+}
+
+} //namespace movelib {
+} //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //BOOST_MOVE_DETAIL_REVERSE_ITERATOR_HPP
diff --git a/boost/move/detail/to_raw_pointer.hpp b/boost/move/detail/to_raw_pointer.hpp
new file mode 100644
index 0000000..7e89beb
--- /dev/null
+++ b/boost/move/detail/to_raw_pointer.hpp
@@ -0,0 +1,45 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2017-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
+#define BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+#include <boost/move/detail/pointer_element.hpp>
+
+namespace boost {
+namespace movelib {
+
+template <class T>
+BOOST_MOVE_FORCEINLINE T* to_raw_pointer(T* p)
+{  return p; }
+
+template <class Pointer>
+BOOST_MOVE_FORCEINLINE typename boost::movelib::pointer_element<Pointer>::type*
+to_raw_pointer(const Pointer &p)
+{  return ::boost::movelib::to_raw_pointer(p.operator->());  }
+
+} //namespace movelib
+} //namespace boost
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
diff --git a/boost/move/detail/type_traits.hpp b/boost/move/detail/type_traits.hpp
index 1b5d838..272cb11 100644
--- a/boost/move/detail/type_traits.hpp
+++ b/boost/move/detail/type_traits.hpp
@@ -967,14 +967,13 @@ typedef union max_align max_align_t;
 #if !defined(BOOST_NO_ALIGNMENT)
 
 template<std::size_t Len, std::size_t Align>
-struct aligned_storage_impl;
+struct aligned_struct;
 
 #define BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(A)\
 template<std::size_t Len>\
-struct BOOST_ALIGNMENT(A) aligned_storage_impl<Len, A>\
+struct BOOST_ALIGNMENT(A) aligned_struct<Len, A>\
 {\
    char dummy[Len];\
-   typedef aligned_storage_impl<Len, A> type;\
 };\
 //
 
@@ -995,6 +994,20 @@ BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT(0x1000)
 
 #undef BOOST_MOVE_ALIGNED_STORAGE_WITH_BOOST_ALIGNMENT
 
+// Workaround for bogus [-Wignored-attributes] warning on GCC 6.x/7.x: don't use a type that "directly" carries the alignment attribute.
+// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82270
+template<std::size_t Len, std::size_t Align>
+struct aligned_struct_wrapper
+{
+   aligned_struct<Len, Align> dummy;
+};
+
+template<std::size_t Len, std::size_t Align>
+struct aligned_storage_impl
+{
+   typedef aligned_struct_wrapper<Len, Align> type;
+};
+
 #else //BOOST_NO_ALIGNMENT
 
 template<class T, std::size_t Len>
diff --git a/boost/move/detail/unique_ptr_meta_utils.hpp b/boost/move/detail/unique_ptr_meta_utils.hpp
index ac270a8..e11124d 100644
--- a/boost/move/detail/unique_ptr_meta_utils.hpp
+++ b/boost/move/detail/unique_ptr_meta_utils.hpp
@@ -446,7 +446,7 @@ class is_convertible
 #define BOOST_MOVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 
diff --git a/boost/mpl/assert.hpp b/boost/mpl/assert.hpp
index 4d860a4..1af1b05 100644
--- a/boost/mpl/assert.hpp
+++ b/boost/mpl/assert.hpp
@@ -56,7 +56,7 @@
 // and GCC (which issues "unused variable" warnings when static constants are used 
 // at a function scope)
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) \
-    || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0)
+    || (BOOST_MPL_CFG_GCC != 0) || (BOOST_MPL_CFG_GPU != 0) || defined(__PGI)
 #   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) enum { expr }
 #else
 #   define BOOST_MPL_AUX_ASSERT_CONSTANT(T, expr) BOOST_STATIC_CONSTANT(T, expr)
diff --git a/boost/mpl/aux_/arithmetic_op.hpp b/boost/mpl/aux_/arithmetic_op.hpp
new file mode 100644
index 0000000..0171db5
--- /dev/null
+++ b/boost/mpl/aux_/arithmetic_op.hpp
@@ -0,0 +1,92 @@
+
+// NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/integral_c.hpp>
+#   include <boost/mpl/aux_/largest_int.hpp>
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#endif
+
+#if !defined(AUX778076_OP_PREFIX)
+#   define AUX778076_OP_PREFIX AUX778076_OP_NAME
+#endif
+
+#include <boost/mpl/aux_/numeric_op.hpp>
+#include <boost/mpl/aux_/config/static_constant.hpp>
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp
+#   include <boost/mpl/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/workaround.hpp>
+#   include <boost/preprocessor/cat.hpp>
+
+
+namespace boost { namespace mpl {
+
+#if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+namespace aux {
+template< typename T, T n1, T n2 >
+struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)
+{
+    BOOST_STATIC_CONSTANT(T, value = (n1 AUX778076_OP_TOKEN n2));
+    typedef integral_c<T,value> type;
+};
+}
+#endif
+
+template<>
+struct AUX778076_OP_IMPL_NAME<integral_c_tag,integral_c_tag>
+{
+    template< typename N1, typename N2 > struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value
+                  AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value
+                )
+            >
+#else
+        : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , N1::value
+            , N2::value
+            >::type
+#endif
+    {
+    };
+};
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#undef AUX778076_OP_TAG_NAME
+#undef AUX778076_OP_IMPL_NAME
+#undef AUX778076_OP_ARITY
+#undef AUX778076_OP_PREFIX
+#undef AUX778076_OP_NAME
+#undef AUX778076_OP_TOKEN
diff --git a/boost/mpl/aux_/insert_impl.hpp b/boost/mpl/aux_/insert_impl.hpp
new file mode 100644
index 0000000..03a304b
--- /dev/null
+++ b/boost/mpl/aux_/insert_impl.hpp
@@ -0,0 +1,68 @@
+
+#ifndef BOOST_MPL_INSERT_IMPL_HPP_INCLUDED
+#define BOOST_MPL_INSERT_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/reverse_fold.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'insert_impl' or the primary 'insert' template
+
+template< typename Tag >
+struct insert_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename T
+        >
+    struct apply
+    {
+        typedef iterator_range<
+              typename begin<Sequence>::type
+            , Pos
+            > first_half_;
+
+        typedef iterator_range<
+              Pos
+            , typename end<Sequence>::type
+            > second_half_;
+
+        typedef typename reverse_fold<
+              second_half_
+            , typename clear<Sequence>::type
+            , push_front<_,_>
+            >::type half_sequence_;
+
+        typedef typename reverse_fold<
+              first_half_
+            , typename push_front<half_sequence_,T>::type
+            , push_front<_,_>
+            >::type type;
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_impl)
+
+}}
+
+#endif // BOOST_MPL_INSERT_IMPL_HPP_INCLUDED
diff --git a/boost/mpl/aux_/insert_range_impl.hpp b/boost/mpl/aux_/insert_range_impl.hpp
new file mode 100644
index 0000000..fa43315
--- /dev/null
+++ b/boost/mpl/aux_/insert_range_impl.hpp
@@ -0,0 +1,80 @@
+
+#ifndef BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/joint_view.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/iter_push_front.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/forwarding.hpp>
+
+#include <boost/type_traits/same_traits.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'insert_range_impl' or the primary 
+// 'insert_range' template
+
+
+template< typename Tag >
+struct insert_range_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename Range
+        >
+    struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
+        : reverse_fold<
+              joint_view<
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view<
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , typename clear<Sequence>::type
+            , insert<_1, begin<_1>, _2>
+            >
+    {
+#else
+    {
+        typedef typename reverse_fold<
+                joint_view<
+                    iterator_range<typename begin<Sequence>::type,Pos>
+                  , joint_view<
+                        Range
+                      , iterator_range<Pos,typename end<Sequence>::type>
+                      >
+                  >
+              , typename clear<Sequence>::type
+              , insert<_1, begin<_1>, _2>
+              >::type type;
+#endif
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_range_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
diff --git a/boost/mpl/aux_/iter_push_front.hpp b/boost/mpl/aux_/iter_push_front.hpp
new file mode 100644
index 0000000..35ccc4d
--- /dev/null
+++ b/boost/mpl/aux_/iter_push_front.hpp
@@ -0,0 +1,36 @@
+
+#ifndef BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+#define BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/deref.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename Sequence
+    , typename Iterator
+    >
+struct iter_push_front
+{
+    typedef typename push_front<
+          Sequence
+        , typename deref<Iterator>::type
+        >::type type;
+};
+
+}}}
+
+#endif // BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
diff --git a/boost/mpl/aux_/joint_iter.hpp b/boost/mpl/aux_/joint_iter.hpp
new file mode 100644
index 0000000..277580e
--- /dev/null
+++ b/boost/mpl/aux_/joint_iter.hpp
@@ -0,0 +1,120 @@
+
+#ifndef BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+#define BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+#include <boost/mpl/aux_/lambda_spec.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include <boost/type_traits/is_same.hpp>
+#endif
+
+namespace boost { namespace mpl {
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+{
+    typedef Iterator1 base;
+    typedef forward_iterator_tag category;
+};
+
+template<
+      typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter<LastIterator1,LastIterator1,Iterator2>
+{
+    typedef Iterator2 base;
+    typedef forward_iterator_tag category;
+};
+
+
+template< typename I1, typename L1, typename I2 >
+struct deref< joint_iter<I1,L1,I2> >
+{
+    typedef typename joint_iter<I1,L1,I2>::base base_;
+    typedef typename deref<base_>::type type;
+};
+
+template< typename I1, typename L1, typename I2 >
+struct next< joint_iter<I1,L1,I2> >
+{
+    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
+};
+
+template< typename L1, typename I2 >
+struct next< joint_iter<L1,L1,I2> >
+{
+    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
+};
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter;
+
+template< bool > struct joint_iter_impl
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I1 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > next;
+        typedef typename deref<I1>::type type;
+    };
+};
+
+template<> struct joint_iter_impl<true>
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I2 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< L1,L1,typename mpl::next<I2>::type > next;
+        typedef typename deref<I2>::type type;
+    };
+};
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+    : joint_iter_impl< is_same<Iterator1,LastIterator1>::value >
+        ::template result_<Iterator1,LastIterator1,Iterator2>
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, joint_iter)
+
+}}
+
+#endif // BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
diff --git a/boost/mpl/aux_/largest_int.hpp b/boost/mpl/aux_/largest_int.hpp
new file mode 100644
index 0000000..feaa1ec
--- /dev/null
+++ b/boost/mpl/aux_/largest_int.hpp
@@ -0,0 +1,63 @@
+
+#ifndef BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
+#define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/aux_/config/integral.hpp>
+#include <boost/config.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct integral_rank;
+
+template<> struct integral_rank<bool>           : int_<1> {};
+template<> struct integral_rank<signed char>    : int_<2> {};
+template<> struct integral_rank<char>           : int_<3> {};
+template<> struct integral_rank<unsigned char>  : int_<4> {};
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+template<> struct integral_rank<wchar_t>        : int_<5> {};
+#endif
+template<> struct integral_rank<short>          : int_<6> {};
+template<> struct integral_rank<unsigned short> : int_<7> {};
+template<> struct integral_rank<int>            : int_<8> {};
+template<> struct integral_rank<unsigned int>   : int_<9> {};
+template<> struct integral_rank<long>           : int_<10> {};
+template<> struct integral_rank<unsigned long>  : int_<11> {};
+
+#if defined(BOOST_HAS_LONG_LONG)
+template<> struct integral_rank<long_long_type> : int_<12> {};
+template<> struct integral_rank<ulong_long_type>: int_<13> {};
+#endif
+
+template< typename T1, typename T2 > struct largest_int
+#if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC)
+    : if_c< 
+          ( integral_rank<T1>::value >= integral_rank<T2>::value )
+        , T1
+        , T2
+        >
+{
+#else
+{
+    enum { rank1 = integral_rank<T1>::value };
+    enum { rank2 = integral_rank<T2>::value };
+    typedef typename if_c< (rank1 >= rank2),T1,T2 >::type type;
+#endif
+};
+
+}}}
+
+#endif // BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED
diff --git a/boost/mpl/insert.hpp b/boost/mpl/insert.hpp
new file mode 100644
index 0000000..5e379a4
--- /dev/null
+++ b/boost/mpl/insert.hpp
@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_INSERT_HPP_INCLUDED
+#define BOOST_MPL_INSERT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/insert_fwd.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/insert_impl.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    , typename BOOST_MPL_AUX_NA_PARAM(Pos_or_T)
+    , typename BOOST_MPL_AUX_NA_PARAM(T)
+    >
+struct insert
+    : insert_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Pos_or_T,T >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert,(Sequence,Pos_or_T,T))
+};
+
+BOOST_MPL_AUX_NA_SPEC(3, insert)
+
+}}
+
+#endif // BOOST_MPL_INSERT_HPP_INCLUDED
diff --git a/boost/mpl/insert_fwd.hpp b/boost/mpl/insert_fwd.hpp
new file mode 100644
index 0000000..ba6b161
--- /dev/null
+++ b/boost/mpl/insert_fwd.hpp
@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_INSERT_FWD_HPP_INCLUDED
+#define BOOST_MPL_INSERT_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct insert_impl;
+template< typename Sequence, typename Pos_or_T, typename T > struct insert;
+
+}}
+
+#endif // BOOST_MPL_INSERT_FWD_HPP_INCLUDED
diff --git a/boost/mpl/insert_range.hpp b/boost/mpl/insert_range.hpp
new file mode 100644
index 0000000..0c362f5
--- /dev/null
+++ b/boost/mpl/insert_range.hpp
@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
+#define BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/insert_range_fwd.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/insert_range_impl.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    , typename BOOST_MPL_AUX_NA_PARAM(Pos)
+    , typename BOOST_MPL_AUX_NA_PARAM(Range)
+    >
+struct insert_range
+    : insert_range_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Pos,Range >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert_range,(Sequence,Pos,Range))
+};
+
+BOOST_MPL_AUX_NA_SPEC(3, insert_range)
+
+}}
+
+#endif // BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
diff --git a/boost/mpl/insert_range_fwd.hpp b/boost/mpl/insert_range_fwd.hpp
new file mode 100644
index 0000000..d9c946f
--- /dev/null
+++ b/boost/mpl/insert_range_fwd.hpp
@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
+#define BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct insert_range_impl;
+template< typename Sequence, typename Pos, typename Range > struct insert_range;
+
+}}
+
+#endif // BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
diff --git a/boost/mpl/joint_view.hpp b/boost/mpl/joint_view.hpp
new file mode 100644
index 0000000..cd9cdda
--- /dev/null
+++ b/boost/mpl/joint_view.hpp
@@ -0,0 +1,65 @@
+
+#ifndef BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
+#define BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#include <boost/mpl/aux_/joint_iter.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/size_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+
+namespace boost { namespace mpl {
+
+namespace aux {
+struct joint_view_tag;
+}
+
+template<>
+struct size_impl< aux::joint_view_tag >
+{
+    template < typename JointView > struct apply
+      : plus<
+            size<typename JointView::sequence1_>
+          , size<typename JointView::sequence2_>
+          >
+    {};
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence1_)
+    , typename BOOST_MPL_AUX_NA_PARAM(Sequence2_)
+    >
+struct joint_view
+{
+    typedef typename mpl::begin<Sequence1_>::type   first1_;
+    typedef typename mpl::end<Sequence1_>::type     last1_;
+    typedef typename mpl::begin<Sequence2_>::type   first2_;
+    typedef typename mpl::end<Sequence2_>::type     last2_;
+
+    // agurt, 25/may/03: for the 'size_traits' implementation above
+    typedef Sequence1_ sequence1_;
+    typedef Sequence2_ sequence2_;
+
+    typedef joint_view type;
+    typedef aux::joint_view_tag tag;
+    typedef joint_iter<first1_,last1_,first2_>  begin;
+    typedef joint_iter<last1_,last1_,last2_>    end;
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, joint_view)
+
+}}
+
+#endif // BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
diff --git a/boost/mpl/plus.hpp b/boost/mpl/plus.hpp
new file mode 100644
index 0000000..455920b
--- /dev/null
+++ b/boost/mpl/plus.hpp
@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_PLUS_HPP_INCLUDED
+#define BOOST_MPL_PLUS_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// Distributed under the Boost Software License, Version 1.0. 
+// (See accompanying file LICENSE_1_0.txt or copy at 
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id$
+// $Date$
+// $Revision$
+
+#define AUX778076_OP_NAME plus
+#define AUX778076_OP_TOKEN +
+#include <boost/mpl/aux_/arithmetic_op.hpp>
+
+#endif // BOOST_MPL_PLUS_HPP_INCLUDED
diff --git a/boost/next_prior.hpp b/boost/next_prior.hpp
index 7854ec4..5de705f 100644
--- a/boost/next_prior.hpp
+++ b/boost/next_prior.hpp
@@ -1,8 +1,11 @@
 //  Boost next_prior.hpp header file  ---------------------------------------//
 
-//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
+//  Copyright (c) Andrey Semashev 2017
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 
 //  See http://www.boost.org/libs/utility for documentation.
 
@@ -13,17 +16,14 @@
 #define BOOST_NEXT_PRIOR_HPP_INCLUDED
 
 #include <iterator>
-#if defined(_MSC_VER) && _MSC_VER <= 1310
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#endif
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/integral_promotion.hpp>
-#include <boost/type_traits/make_signed.hpp>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/has_plus.hpp>
 #include <boost/type_traits/has_plus_assign.hpp>
 #include <boost/type_traits/has_minus.hpp>
 #include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
 
 namespace boost {
 
@@ -39,18 +39,51 @@ namespace boost {
 
 namespace next_prior_detail {
 
-template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
-struct next_impl2
+// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+template< typename T, typename Void = void >
+struct is_iterator_class
 {
-    static T call(T x, Distance n)
-    {
-        std::advance(x, n);
-        return x;
-    }
+    static BOOST_CONSTEXPR_OR_CONST bool value = false;
 };
 
+template< typename T >
+struct is_iterator_class<
+    T,
+    typename enable_if_has_type<
+#if !defined(BOOST_NO_CXX17_ITERATOR_TRAITS)
+        typename std::iterator_traits< T >::iterator_category
+#else
+        typename T::iterator_category
+#endif
+    >::type
+>
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+template< typename T >
+struct is_iterator :
+    public is_iterator_class< T >
+{
+};
+
+template< typename T >
+struct is_iterator< T* >
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_plus_impl;
+
 template< typename T, typename Distance >
-struct next_impl2< T, Distance, true >
+struct next_plus_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -58,15 +91,14 @@ struct next_impl2< T, Distance, true >
     }
 };
 
-
 template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
-struct next_impl1 :
-    public next_impl2< T, Distance >
+struct next_plus_assign_impl :
+    public next_plus_impl< T, Distance >
 {
 };
 
 template< typename T, typename Distance >
-struct next_impl1< T, Distance, true >
+struct next_plus_assign_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -75,47 +107,28 @@ struct next_impl1< T, Distance, true >
     }
 };
 
-
-template<
-    typename T,
-    typename Distance,
-    typename PromotedDistance = typename integral_promotion< Distance >::type,
-#if !defined(_MSC_VER) || _MSC_VER > 1310
-    bool IsUInt = is_unsigned< PromotedDistance >::value
-#else
-    // MSVC 7.1 has problems with applying is_unsigned to non-integral types
-    bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
-#endif
->
-struct prior_impl3
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct next_advance_impl :
+    public next_plus_assign_impl< T, Distance >
 {
-    static T call(T x, Distance n)
-    {
-        std::advance(x, -n);
-        return x;
-    }
 };
 
-template< typename T, typename Distance, typename PromotedDistance >
-struct prior_impl3< T, Distance, PromotedDistance, true >
+template< typename T, typename Distance >
+struct next_advance_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
-        typedef typename make_signed< PromotedDistance >::type signed_distance;
-        std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
+        boost::iterators::advance(x, n);
         return x;
     }
 };
 
 
 template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
-struct prior_impl2 :
-    public prior_impl3< T, Distance >
-{
-};
+struct prior_minus_impl;
 
 template< typename T, typename Distance >
-struct prior_impl2< T, Distance, true >
+struct prior_minus_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -123,15 +136,14 @@ struct prior_impl2< T, Distance, true >
     }
 };
 
-
 template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
-struct prior_impl1 :
-    public prior_impl2< T, Distance >
+struct prior_minus_assign_impl :
+    public prior_minus_impl< T, Distance >
 {
 };
 
 template< typename T, typename Distance >
-struct prior_impl1< T, Distance, true >
+struct prior_minus_assign_impl< T, Distance, true >
 {
     static T call(T x, Distance n)
     {
@@ -140,6 +152,24 @@ struct prior_impl1< T, Distance, true >
     }
 };
 
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct prior_advance_impl :
+    public prior_minus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        // Avoid negating n to sidestep possible integer overflow
+        boost::iterators::reverse_iterator< T > rx(x);
+        boost::iterators::advance(rx, n);
+        return rx.base();
+    }
+};
+
 } // namespace next_prior_detail
 
 template <class T>
@@ -148,7 +178,7 @@ inline T next(T x) { return ++x; }
 template <class T, class Distance>
 inline T next(T x, Distance n)
 {
-    return next_prior_detail::next_impl1< T, Distance >::call(x, n);
+    return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
 }
 
 template <class T>
@@ -157,7 +187,7 @@ inline T prior(T x) { return --x; }
 template <class T, class Distance>
 inline T prior(T x, Distance n)
 {
-    return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
+    return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
 }
 
 } // namespace boost
diff --git a/boost/optional/detail/old_optional_implementation.hpp b/boost/optional/detail/old_optional_implementation.hpp
index f2e6718..4e888ed 100644
--- a/boost/optional/detail/old_optional_implementation.hpp
+++ b/boost/optional/detail/old_optional_implementation.hpp
@@ -746,12 +746,12 @@ class optional : public optional_detail::optional_base<T>
     optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
 
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
-	// Creates a deep move of another optional<T>
-	// Can throw if T::T(T&&) does
-	optional ( optional && rhs ) 
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
-	  : base( boost::move(rhs) ) 
-	{}
+    // Creates a deep move of another optional<T>
+    // Can throw if T::T(T&&) does
+    optional ( optional && rhs )
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
+      : base( boost::move(rhs) )
+    {}
 
 #endif
    // No-throw (assuming T::~T() doesn't)
@@ -819,7 +819,7 @@ class optional : public optional_detail::optional_base<T>
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from another optional<T> (deep-moves the rhs value)
     optional& operator= ( optional && rhs ) 
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         this->assign( static_cast<base &&>(rhs) ) ;
         return *this ;
@@ -892,7 +892,7 @@ class optional : public optional_detail::optional_base<T>
 #endif
 
     void swap( optional & arg )
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         // allow for Koenig lookup
         boost::swap(*this, arg);
diff --git a/boost/optional/detail/optional_aligned_storage.hpp b/boost/optional/detail/optional_aligned_storage.hpp
index 6c7d581..2937349 100644
--- a/boost/optional/detail/optional_aligned_storage.hpp
+++ b/boost/optional/detail/optional_aligned_storage.hpp
@@ -25,12 +25,8 @@ template <class T>
 class aligned_storage
 {
     // Borland ICEs if unnamed unions are used for this!
-    union
-    // This works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
-#if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
-    __attribute__((__may_alias__))
-#endif
-    dummy_u
+    // BOOST_MAY_ALIAS works around GCC warnings about breaking strict aliasing rules when casting storage address to T*
+    union BOOST_MAY_ALIAS dummy_u
     {
         char data[ sizeof(T) ];
         BOOST_DEDUCED_TYPENAME type_with_alignment<
@@ -48,24 +44,24 @@ class aligned_storage
 #endif
 
 #if defined(BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS)
-	// This workaround is supposed to silence GCC warnings about broken strict aliasing rules
-	T const* ptr_ref() const
-	{
-		union { void const* ap_pvoid; T const* as_ptype; } caster = { address() };
-		return caster.as_ptype;
-	}
-	T *      ptr_ref()
-	{
-		union { void* ap_pvoid; T* as_ptype; } caster = { address() };
-		return caster.as_ptype;
-	}
+    // This workaround is supposed to silence GCC warnings about broken strict aliasing rules
+    T const* ptr_ref() const
+    {
+        union { void const* ap_pvoid; T const* as_ptype; } caster = { address() };
+        return caster.as_ptype;
+    }
+    T *      ptr_ref()
+    {
+        union { void* ap_pvoid; T* as_ptype; } caster = { address() };
+        return caster.as_ptype;
+    }
 #else
-	T const* ptr_ref() const { return static_cast<T const*>(address()); }
-	T *      ptr_ref()       { return static_cast<T *>     (address()); }
+    T const* ptr_ref() const { return static_cast<T const*>(address()); }
+    T *      ptr_ref()       { return static_cast<T *>     (address()); }
 #endif
 
-	T const& ref() const { return *ptr_ref(); }
-	T &      ref()       { return *ptr_ref(); }
+    T const& ref() const { return *ptr_ref(); }
+    T &      ref()       { return *ptr_ref(); }
   
 } ;
 
diff --git a/boost/optional/detail/optional_config.hpp b/boost/optional/detail/optional_config.hpp
index e26d73c..bb7e12f 100644
--- a/boost/optional/detail/optional_config.hpp
+++ b/boost/optional/detail/optional_config.hpp
@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2015 Andrzej Krzemienski.
+// Copyright (C) 2015 - 2017 Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -44,11 +44,11 @@
 # define BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
 #endif
 
-#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
-// GCC since 3.3 has may_alias attribute that helps to alleviate optimizer issues with
-// regard to violation of the strict aliasing rules. The optional< T > storage type is marked
-// with this attribute in order to let the compiler know that it will alias objects of type T
-// and silence compilation warnings.
+#if !defined(BOOST_NO_MAY_ALIAS)
+// GCC since 3.3 and some other compilers have may_alias attribute that helps to alleviate
+// optimizer issues with regard to violation of the strict aliasing rules. The optional< T >
+// storage type is marked with this attribute in order to let the compiler know that it will
+// alias objects of type T and silence compilation warnings.
 # define BOOST_OPTIONAL_DETAIL_USE_ATTRIBUTE_MAY_ALIAS
 #endif
 
@@ -113,4 +113,23 @@
 # define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
 #endif
 
+
+// Detect suport for defaulting move operations
+// (some older compilers implement rvalue references,
+// defaulted funcitons but move operations are not special members and cannot be defaulted)
+
+#ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#elif BOOST_WORKAROUND(BOOST_MSVC, < 1900)
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#elif BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600)
+# define BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+#endif
+
+
+#ifdef BOOST_OPTIONAL_CONFIG_NO_DIRECT_STORAGE_SPEC
+# define BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC
+#endif
+
+
 #endif // header guard
diff --git a/boost/optional/detail/optional_relops.hpp b/boost/optional/detail/optional_relops.hpp
index 3f96117..2c17f2b 100644
--- a/boost/optional/detail/optional_relops.hpp
+++ b/boost/optional/detail/optional_relops.hpp
@@ -26,7 +26,7 @@ namespace boost {
 template<class T>
 inline
 bool operator == ( optional<T> const& x, optional<T> const& y )
-{ return equal_pointees(x,y); }
+{ return bool(x) && bool(y) ? *x == *y : bool(x) == bool(y); }
 
 template<class T>
 inline
diff --git a/boost/optional/detail/optional_trivially_copyable_base.hpp b/boost/optional/detail/optional_trivially_copyable_base.hpp
new file mode 100644
index 0000000..91328ac
--- /dev/null
+++ b/boost/optional/detail/optional_trivially_copyable_base.hpp
@@ -0,0 +1,499 @@
+// trivilally-copyable version of the storage
+
+template<class T>
+class tc_optional_base : public optional_tag
+{
+  private :
+
+    typedef tc_optional_base<T> this_type ;
+
+  protected :
+
+    typedef T value_type ;
+
+  protected:
+    typedef T &       reference_type ;
+    typedef T const&  reference_const_type ;
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    typedef T &&  rval_reference_type ;
+    typedef T &&  reference_type_of_temporary_wrapper ;
+#endif
+    typedef T *         pointer_type ;
+    typedef T const*    pointer_const_type ;
+    typedef T const&    argument_type ;
+
+    tc_optional_base()
+      :
+      m_initialized(false) {}
+
+    tc_optional_base ( none_t )
+      :
+      m_initialized(false) {}
+
+    tc_optional_base ( argument_type val )
+      :
+      m_initialized(true), m_storage(val) {}
+
+    tc_optional_base ( bool cond, argument_type val )
+      :
+      m_initialized(cond), m_storage(val) {}
+
+    // tc_optional_base ( tc_optional_base const& ) = default;
+
+
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+    template<class Expr, class PtrExpr>
+    explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
+      :
+      m_initialized(false)
+    {
+      construct(boost::forward<Expr>(expr),tag);
+    }
+
+#else
+    // This is used for both converting and in-place constructions.
+    // Derived classes use the 'tag' to select the appropriate
+    // implementation (the correct 'construct()' overload)
+    template<class Expr>
+    explicit tc_optional_base ( Expr const& expr, Expr const* tag )
+      :
+      m_initialized(false)
+    {
+      construct(expr,tag);
+    }
+
+#endif
+
+    // tc_optional_base& operator= ( tc_optional_base const& ) = default;
+    // ~tc_optional_base() = default;
+
+    // Assigns from another optional<T> (deep-copies the rhs value)
+    void assign ( tc_optional_base const& rhs ) 
+    {
+      this->operator=(rhs);
+    }
+
+    // Assigns from another _convertible_ optional<U> (deep-copies the rhs value)
+    template<class U>
+    void assign ( optional<U> const& rhs )
+    {
+      if ( rhs.is_initialized() )
+#ifndef BOOST_OPTIONAL_CONFIG_RESTORE_ASSIGNMENT_OF_NONCONVERTIBLE_TYPES
+        m_storage = rhs.get();
+#else
+        m_storage = static_cast<value_type>(rhs.get());
+#endif
+          
+      m_initialized = rhs.is_initialized();
+    }
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    // move-assigns from another _convertible_ optional<U> (deep-moves from the rhs value)
+    template<class U>
+    void assign ( optional<U>&& rhs )
+    {
+      typedef BOOST_DEDUCED_TYPENAME optional<U>::rval_reference_type ref_type;
+      if ( rhs.is_initialized() )
+        m_storage = static_cast<ref_type>(rhs.get());
+      m_initialized = rhs.is_initialized();
+    }
+#endif
+    
+    void assign ( argument_type val )
+    {
+      construct(val);
+    }
+
+    void assign ( none_t ) { destroy(); }
+
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    template<class Expr, class ExprPtr>
+    void assign_expr ( Expr&& expr, ExprPtr const* tag )
+    {
+       construct(boost::forward<Expr>(expr),tag);
+    }
+#else
+    template<class Expr>
+    void assign_expr ( Expr const& expr, Expr const* tag )
+    {
+      construct(expr,tag);
+    }
+#endif
+
+#endif
+
+  public :
+
+    // **DEPPRECATED** Destroys the current value, if any, leaving this UNINITIALIZED
+    // No-throw (assuming T::~T() doesn't)
+    void reset() BOOST_NOEXCEPT { destroy(); }
+
+    // **DEPPRECATED** Replaces the current value -if any- with 'val'
+    void reset ( argument_type val ) BOOST_NOEXCEPT { assign(val); }
+
+    // Returns a pointer to the value if this is initialized, otherwise,
+    // returns NULL.
+    // No-throw
+    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
+    pointer_type       get_ptr()       { return m_initialized ? get_ptr_impl() : 0 ; }
+
+    bool is_initialized() const { return m_initialized ; }
+
+  protected :
+
+    void construct ( argument_type val )
+     {
+       m_storage = val ;
+       m_initialized = true ;
+     }
+
+
+#if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    // Constructs in-place
+    // upon exception *this is always uninitialized
+    template<class... Args>
+    void construct ( in_place_init_t, Args&&... args )
+    {
+      m_storage = value_type( boost::forward<Args>(args)... ) ;
+      m_initialized = true ;
+    }
+
+    template<class... Args>
+    void emplace_assign ( Args&&... args )
+    {
+      construct(in_place_init, boost::forward<Args>(args)...);
+    }
+     
+    template<class... Args>
+    explicit tc_optional_base ( in_place_init_t, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init, boost::forward<Args>(args)...);
+    }
+    
+    template<class... Args>
+    explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, boost::forward<Args>(args)...);
+    }
+#elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
+    template<class Arg>
+    void construct ( in_place_init_t, Arg&& arg )
+     {
+       m_storage = value_type( boost::forward<Arg>(arg) );
+       m_initialized = true ;
+     }
+     
+    void construct ( in_place_init_t )
+     {
+       m_storage = value_type();
+       m_initialized = true ;
+     }
+     
+    template<class Arg>
+    void emplace_assign ( Arg&& arg )
+     {
+       construct(in_place_init, boost::forward<Arg>(arg)) ;
+     }
+     
+    void emplace_assign ()
+     {
+       construct(in_place_init) ;
+     }
+     
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_t, Arg&& arg )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init, boost::forward<Arg>(arg));
+    }
+    
+    explicit tc_optional_base ( in_place_init_t )
+      :
+      m_initialized(false), m_storage() {}
+    
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg&& arg )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, boost::forward<Arg>(arg));
+    }
+    
+    explicit tc_optional_base ( in_place_init_if_t, bool cond )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init);
+    }
+
+#else
+     
+    template<class Arg>
+    void construct ( in_place_init_t, const Arg& arg )
+     {
+       m_storage = value_type( arg );
+       m_initialized = true ;
+     }
+     
+    template<class Arg>
+    void construct ( in_place_init_t, Arg& arg )
+     {
+       m_storage = value_type( arg );
+       m_initialized = true ;
+     }
+     
+    void construct ( in_place_init_t )
+     {
+       m_storage = value_type();
+       m_initialized = true ;
+     }
+
+    template<class Arg>
+    void emplace_assign ( const Arg& arg )
+    {
+      construct(in_place_init, arg);
+    }
+     
+    template<class Arg>
+    void emplace_assign ( Arg& arg )
+    {
+      construct(in_place_init, arg);
+    }
+     
+    void emplace_assign ()
+    {
+      construct(in_place_init);
+    }
+    
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_t, const Arg& arg )
+      : m_initialized(false)
+    {
+      construct(in_place_init, arg);
+    }
+
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_t, Arg& arg )
+      : m_initialized(false)
+    {
+      construct(in_place_init, arg);
+    }
+    
+    explicit tc_optional_base ( in_place_init_t )
+      : m_initialized(false)
+    {
+      construct(in_place_init);
+    }
+    
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_if_t, bool cond, const Arg& arg )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, arg);
+    }
+    
+    template<class Arg>
+    explicit tc_optional_base ( in_place_init_if_t, bool cond, Arg& arg )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, arg);
+    } 
+    
+    explicit tc_optional_base ( in_place_init_if_t, bool cond )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init);
+    }
+#endif
+
+#ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    // Constructs in-place using the given factory
+    template<class Expr>
+    void construct ( Expr&& factory, in_place_factory_base const* )
+     {
+       boost_optional_detail::construct<value_type>(factory, boost::addressof(m_storage));
+       m_initialized = true ;
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void construct ( Expr&& factory, typed_in_place_factory_base const* )
+     {
+       factory.apply(boost::addressof(m_storage)) ;
+       m_initialized = true ;
+     }
+
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+
+#else
+    // Constructs in-place using the given factory
+    template<class Expr>
+    void construct ( Expr const& factory, in_place_factory_base const* )
+     {
+       boost_optional_detail::construct<value_type>(factory, m_storage.address());
+       m_initialized = true ;
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void construct ( Expr const& factory, typed_in_place_factory_base const* )
+     {
+       factory.apply(boost::addressof(m_storage)) ;
+       m_initialized = true ;
+     }
+
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& factory, in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+
+    // Constructs in-place using the given typed factory
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& factory, typed_in_place_factory_base const* tag )
+     {
+       destroy();
+       construct(factory,tag);
+     }
+#endif
+
+#endif
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    // Constructs using any expression implicitly convertible to the single argument
+    // of a one-argument T constructor.
+    // Converting constructions of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
+    template<class Expr>
+    void construct ( Expr&& expr, void const* )
+    {
+      m_storage = value_type(boost::forward<Expr>(expr)) ;
+      m_initialized = true ;
+    }
+
+    // Assigns using a form any expression implicitly convertible to the single argument
+    // of a T's assignment operator.
+    // Converting assignments of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr&& expr, void const* )
+    {
+      assign_value( boost::forward<Expr>(expr) );
+    }
+#else
+    // Constructs using any expression implicitly convertible to the single argument
+    // of a one-argument T constructor.
+    // Converting constructions of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting constructor of T from U.
+    template<class Expr>
+    void construct ( Expr const& expr, void const* )
+     {
+       m_storage = value_type(expr) ;
+       m_initialized = true ;
+     }
+
+    // Assigns using a form any expression implicitly convertible to the single argument
+    // of a T's assignment operator.
+    // Converting assignments of optional<T> from optional<U> uses this function with
+    // 'Expr' being of type 'U' and relying on a converting assignment of T from U.
+    template<class Expr>
+    void assign_expr_to_initialized ( Expr const& expr, void const* )
+     {
+       assign_value(expr);
+     }
+
+#endif
+
+#ifdef BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+    // BCB5.64 (and probably lower versions) workaround.
+    //   The in-place factories are supported by means of catch-all constructors
+    //   and assignment operators (the functions are parameterized in terms of
+    //   an arbitrary 'Expr' type)
+    //   This compiler incorrectly resolves the overload set and sinks optional<T> and optional<U>
+    //   to the 'Expr'-taking functions even though explicit overloads are present for them.
+    //   Thus, the following overload is needed to properly handle the case when the 'lhs'
+    //   is another optional.
+    //
+    // For VC<=70 compilers this workaround dosen't work becasue the comnpiler issues and error
+    // instead of choosing the wrong overload
+    //
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
+    template<class Expr>
+    void construct ( Expr&& expr, optional_tag const* )
+     {
+       if ( expr.is_initialized() )
+       {
+         // An exception can be thrown here.
+         // It it happens, THIS will be left uninitialized.
+         m_storage = value_type(boost::move(expr.get())) ;
+         m_initialized = true ;
+       }
+     }
+#else
+    // Notice that 'Expr' will be optional<T> or optional<U> (but not tc_optional_base<..>)
+    template<class Expr>
+    void construct ( Expr const& expr, optional_tag const* )
+     {
+       if ( expr.is_initialized() )
+       {
+         // An exception can be thrown here.
+         // It it happens, THIS will be left uninitialized.
+         m_storage = value_type(expr.get()) ;
+         m_initialized = true ;
+       }
+     }
+#endif
+#endif // defined BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION
+
+    void assign_value ( argument_type val ) { m_storage = val; }
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    void assign_value ( rval_reference_type val ) { m_storage = static_cast<rval_reference_type>(val); }
+#endif
+
+    void destroy()
+    {
+      m_initialized = false;
+    }
+
+    reference_const_type get_impl() const { return m_storage ; }
+    reference_type       get_impl()       { return m_storage ; }
+
+    pointer_const_type get_ptr_impl() const { return boost::addressof(m_storage); }
+    pointer_type       get_ptr_impl()       { return boost::addressof(m_storage); }
+
+  private :
+
+    bool m_initialized ;
+    T    m_storage ;
+} ;
diff --git a/boost/optional/optional.hpp b/boost/optional/optional.hpp
index a465b9e..c0f10e1 100644
--- a/boost/optional/optional.hpp
+++ b/boost/optional/optional.hpp
@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2014 - 2016 Andrzej Krzemienski.
+// Copyright (C) 2014 - 2017 Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +20,10 @@
 #include <new>
 #include <iosfwd>
 
+#ifdef BOOST_OPTIONAL_DETAIL_USE_STD_TYPE_TRAITS
+#  include <type_traits>
+#endif
+
 #include <boost/assert.hpp>
 #include <boost/core/addressof.hpp>
 #include <boost/core/enable_if.hpp>
@@ -37,12 +41,15 @@
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/decay.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_constructible.hpp>
 #include <boost/type_traits/is_lvalue_reference.hpp>
 #include <boost/type_traits/is_nothrow_move_assignable.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
 #include <boost/type_traits/is_rvalue_reference.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/is_scalar.hpp>
 #include <boost/move/utility.hpp>
 #include <boost/none.hpp>
 #include <boost/utility/compare_pointees.hpp>
@@ -67,7 +74,7 @@ struct in_place_init_t
 };            
 const in_place_init_t in_place_init ((in_place_init_t::init_tag()));
 
-// a tag for conditional in-place initialization of contained value	
+// a tag for conditional in-place initialization of contained value
 struct in_place_init_if_t
 {
   struct init_tag{};
@@ -152,6 +159,18 @@ class optional_base : public optional_tag
         construct(val);
     }
 
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    // Creates an optional<T> initialized with 'move(val)' IFF cond is true, otherwise creates an uninitialzed optional<T>.
+    // Can throw if T::T(T &&) does
+    optional_base ( bool cond, rval_reference_type val )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(boost::move(val));
+    }
+#endif
+
     // Creates a deep copy of another optional<T>
     // Can throw if T::T(T const&) does
     optional_base ( optional_base const& rhs )
@@ -166,6 +185,7 @@ class optional_base : public optional_tag
     // Creates a deep move of another optional<T>
     // Can throw if T::T(T&&) does
     optional_base ( optional_base&& rhs )
+    BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
       :
       m_initialized(false)
     {
@@ -198,6 +218,20 @@ class optional_base : public optional_tag
 
 #endif
 
+    optional_base& operator= ( optional_base const& rhs )
+    {
+      this->assign(rhs);
+      return *this;
+    }
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    optional_base& operator= ( optional_base && rhs )
+    BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+    {
+      this->assign(static_cast<optional_base&&>(rhs));
+      return *this;
+    }
+#endif
 
     // No-throw (assuming T::~T() doesn't)
     ~optional_base() { destroy() ; }
@@ -723,6 +757,10 @@ class optional_base : public optional_tag
     storage_type m_storage ;
 } ;
 
+
+
+#include <boost/optional/detail/optional_trivially_copyable_base.hpp>
+
 // definition of metafunciton is_optional_val_init_candidate
 template <typename U>
 struct is_optional_related
@@ -764,13 +802,34 @@ struct is_optional_val_init_candidate
   : boost::conditional< !is_optional_related<U>::value && is_convertible_to_T_or_factory<T, U>::value
                       , boost::true_type, boost::false_type>::type
 {};
-    
+
 } // namespace optional_detail
 
+namespace optional_config {
+
+template <typename T>
+struct optional_uses_direct_storage_for
+  : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
+                      , boost::true_type, boost::false_type>::type
+{};
+
+} // namespace optional_config
+
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_DIRECT_STORAGE_SPEC
+#  define BOOST_OPTIONAL_BASE_TYPE(T) boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, \
+                                      optional_detail::tc_optional_base<T>, \
+                                      optional_detail::optional_base<T> \
+                                      >::type
+#else
+#  define BOOST_OPTIONAL_BASE_TYPE(T) optional_detail::optional_base<T>
+#endif
+
 template<class T>
-class optional : public optional_detail::optional_base<T>
+class optional
+  : public BOOST_OPTIONAL_BASE_TYPE(T)
 {
-    typedef optional_detail::optional_base<T> base ;
+    typedef typename BOOST_OPTIONAL_BASE_TYPE(T) base ;
 
   public :
 
@@ -810,6 +869,13 @@ class optional : public optional_detail::optional_base<T>
     // Can throw if T::T(T const&) does
     optional ( bool cond, argument_type val ) : base(cond,val) {}
 
+#ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+    /// Creates an optional<T> initialized with 'val' IFF cond is true, otherwise creates an uninitialized optional.
+    // Can throw if T::T(T &&) does
+    optional ( bool cond, rval_reference_type val ) : base( cond, boost::forward<T>(val) ) 
+      {}
+#endif
+
     // NOTE: MSVC needs templated versions first
 
     // Creates a deep copy of another convertible optional<U>
@@ -823,7 +889,7 @@ class optional : public optional_detail::optional_base<T>
                       )
       :
       base()
-    {
+    {      
       if ( rhs.is_initialized() )
         this->construct(rhs.get());
     }
@@ -874,15 +940,24 @@ class optional : public optional_detail::optional_base<T>
 
     // Creates a deep copy of another optional<T>
     // Can throw if T::T(T const&) does
+#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+    optional ( optional const& ) = default;
+#else
     optional ( optional const& rhs ) : base( static_cast<base const&>(rhs) ) {}
+#endif
 
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
-	// Creates a deep move of another optional<T>
-	// Can throw if T::T(T&&) does
-	optional ( optional && rhs ) 
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
-	  : base( boost::move(rhs) ) 
-	{}
+    // Creates a deep move of another optional<T>
+    // Can throw if T::T(T&&) does
+
+#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+    optional ( optional && rhs ) = default;
+#else
+    optional ( optional && rhs )
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value)
+      : base( boost::move(rhs) )
+    {}
+#endif
 
 #endif
 
@@ -891,7 +966,7 @@ class optional : public optional_detail::optional_base<T>
     ~optional() {}
 #endif
 
-	
+
 #if !defined(BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT) && !defined(BOOST_OPTIONAL_WEAK_OVERLOAD_RESOLUTION)
     // Assigns from an expression. See corresponding constructor.
     // Basic Guarantee: If the resolved T ctor throws, this is left UNINITIALIZED
@@ -940,21 +1015,30 @@ class optional : public optional_detail::optional_base<T>
     // Assigns from another optional<T> (deep-copies the rhs value)
     // Basic Guarantee: If T::T( T const& ) throws, this is left UNINITIALIZED
     //  (NOTE: On BCB, this operator is not actually called and left is left UNMODIFIED in case of a throw)
+#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+    optional& operator= ( optional const& rhs ) = default;
+#else
     optional& operator= ( optional const& rhs )
       {
         this->assign( static_cast<base const&>(rhs) ) ;
         return *this ;
       }
+#endif
 
 #ifndef  BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from another optional<T> (deep-moves the rhs value)
+#ifndef BOOST_OPTIONAL_DETAIL_NO_DEFAULTED_MOVE_FUNCTIONS
+    optional& operator= ( optional && ) = default;
+#else
     optional& operator= ( optional && rhs ) 
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         this->assign( static_cast<base &&>(rhs) ) ;
         return *this ;
       }
-#endif
+#endif      
+      
+#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
 #ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
 
@@ -1093,7 +1177,7 @@ class optional : public optional_detail::optional_base<T>
 #endif
 
     void swap( optional & arg )
-	  BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
+      BOOST_NOEXCEPT_IF(::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value)
       {
         // allow for Koenig lookup
         boost::swap(*this, arg);
@@ -1276,6 +1360,25 @@ class optional<T&&>
 
 namespace boost {
 
+#ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
+template<class T>
+inline
+optional<BOOST_DEDUCED_TYPENAME boost::decay<T>::type> make_optional ( T && v  )
+{
+  return optional<BOOST_DEDUCED_TYPENAME boost::decay<T>::type>(boost::forward<T>(v));
+}
+
+// Returns optional<T>(cond,v)
+template<class T>
+inline
+optional<BOOST_DEDUCED_TYPENAME boost::decay<T>::type> make_optional ( bool cond, T && v )
+{
+  return optional<BOOST_DEDUCED_TYPENAME boost::decay<T>::type>(cond,boost::forward<T>(v));
+}
+
+#else
+
 // Returns optional<T>(v)
 template<class T>
 inline
@@ -1292,6 +1395,8 @@ optional<T> make_optional ( bool cond, T const& v )
   return optional<T>(cond,v);
 }
 
+#endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
+
 // Returns a reference to the value if this is initialized, otherwise, the behaviour is UNDEFINED.
 // No-throw
 template<class T>
diff --git a/boost/preprocessor/config/config.hpp b/boost/preprocessor/config/config.hpp
index 4801903..28dcdd4 100644
--- a/boost/preprocessor/config/config.hpp
+++ b/boost/preprocessor/config/config.hpp
@@ -25,18 +25,16 @@
 # define BOOST_PP_CONFIG_DMC() 0x0040
 #
 # ifndef BOOST_PP_CONFIG_FLAGS
-#    if defined(__GCCXML__)
-#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
-#    elif defined(__WAVE__)
-#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
-#    elif defined(__MWERKS__) && __MWERKS__ >= 0x3200
+#    if defined(__GCCXML__) || defined(__WAVE__) || defined(__MWERKS__) && __MWERKS__ >= 0x3200
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
 #    elif defined(__EDG__) || defined(__EDG_VERSION__)
-#        if defined(_MSC_VER) && (defined(__clang__) || defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
+#        if defined(_MSC_VER) && !defined(__clang__) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
 #            define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC())
 #        else
 #            define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT())
 #        endif
+#    elif defined(_MSC_VER) && defined(__clang__)
+#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
 #    elif defined(__MWERKS__)
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MWCC())
 #    elif defined(__DMC__)
@@ -75,8 +73,10 @@
 #    /* variadic support explicitly disabled for all untested compilers */
 #    if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || ( defined __SUNPRO_CC && __SUNPRO_CC < 0x5120 ) || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI
 #        define BOOST_PP_VARIADICS 0
+#    elif defined(_MSC_VER) && defined(__clang__)
+#        define BOOST_PP_VARIADICS 1
 #    /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */
-#    elif defined _MSC_VER && _MSC_VER >= 1400 && (defined(__clang__) || !defined __EDG__ || defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700)
+#    elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700)
 #        define BOOST_PP_VARIADICS 1
 #        undef BOOST_PP_VARIADICS_MSVC
 #        define BOOST_PP_VARIADICS_MSVC 1
@@ -92,7 +92,7 @@
 # elif !BOOST_PP_VARIADICS + 1 < 2
 #    undef BOOST_PP_VARIADICS
 #    define BOOST_PP_VARIADICS 1
-#    if defined _MSC_VER && _MSC_VER >= 1400 && (defined(__clang__) || defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
+#    if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
 #        undef BOOST_PP_VARIADICS_MSVC
 #        define BOOST_PP_VARIADICS_MSVC 1
 #    endif
diff --git a/boost/range/concepts.hpp b/boost/range/concepts.hpp
index 3e612a3..87c1e98 100644
--- a/boost/range/concepts.hpp
+++ b/boost/range/concepts.hpp
@@ -25,6 +25,8 @@
 #include <boost/range/detail/misc_concept.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
+#include <iterator>
+
 /*!
  * \file
  * \brief Concept checks for the Boost Range library.
@@ -164,10 +166,10 @@ namespace boost {
                 // work
                 (void)(i++);
 
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r1(*i);
+                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r1(*i);
                 boost::ignore_unused_variable_warning(r1);
 
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
+                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r2(*(++i));
                 boost::ignore_unused_variable_warning(r2);
             }
         private:
@@ -181,7 +183,7 @@ namespace boost {
             , DefaultConstructible<Iterator>
         {
 #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+            typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::difference_type difference_type;
 
             BOOST_MPL_ASSERT((is_integral<difference_type>));
             BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
@@ -200,7 +202,7 @@ namespace boost {
                 // is convertible to reference.
                 Iterator i2(i++);
                 boost::ignore_unused_variable_warning(i2);
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r(*(i++));
+                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r(*(i++));
                 boost::ignore_unused_variable_warning(r);
             }
         private:
diff --git a/boost/smart_ptr/detail/operator_bool.hpp b/boost/smart_ptr/detail/operator_bool.hpp
index c0289b8..f9c5ef6 100644
--- a/boost/smart_ptr/detail/operator_bool.hpp
+++ b/boost/smart_ptr/detail/operator_bool.hpp
@@ -9,14 +9,14 @@
 #if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
     && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
 
-    explicit operator bool () const BOOST_NOEXCEPT
+    explicit operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
 
 #elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
 
-    operator bool () const BOOST_NOEXCEPT
+    operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
@@ -29,7 +29,7 @@
 
     typedef void (*unspecified_bool_type)( this_type*** );
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: unspecified_bool;
     }
@@ -41,7 +41,7 @@
 
     typedef element_type * (this_type::*unspecified_bool_type)() const;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::get;
     }
@@ -50,7 +50,7 @@
 
     typedef element_type * this_type::*unspecified_bool_type;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::px;
     }
@@ -58,7 +58,7 @@
 #endif
 
     // operator! is redundant, but some compilers need it
-    bool operator! () const BOOST_NOEXCEPT
+    bool operator! () const BOOST_SP_NOEXCEPT
     {
         return px == 0;
     }
diff --git a/boost/smart_ptr/detail/sp_noexcept.hpp b/boost/smart_ptr/detail/sp_noexcept.hpp
index 6818dce..1287ba4 100644
--- a/boost/smart_ptr/detail/sp_noexcept.hpp
+++ b/boost/smart_ptr/detail/sp_noexcept.hpp
@@ -9,7 +9,7 @@
 
 //  detail/sp_noexcept.hpp
 //
-//  Copyright 2016 Peter Dimov
+//  Copyright 2016, 2017 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //  See accompanying file LICENSE_1_0.txt or copy at
@@ -17,13 +17,31 @@
 
 #include <boost/config.hpp>
 
+// BOOST_SP_NOEXCEPT
+
 #if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
 
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
 
 #else
 
-#define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+
+#endif
+
+// BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#else
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
 
 #endif
 
diff --git a/boost/smart_ptr/intrusive_ptr.hpp b/boost/smart_ptr/intrusive_ptr.hpp
index 0e46212..0ab075d 100644
--- a/boost/smart_ptr/intrusive_ptr.hpp
+++ b/boost/smart_ptr/intrusive_ptr.hpp
@@ -6,11 +6,11 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>
@@ -141,7 +141,7 @@ public:
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
@@ -161,7 +161,7 @@ public:
         return *this;
     }
 
-    void reset() BOOST_NOEXCEPT
+    void reset()
     {
         this_type().swap( *this );
     }
@@ -176,25 +176,25 @@ public:
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
 
-    T * detach() BOOST_NOEXCEPT
+    T * detach() BOOST_SP_NOEXCEPT
     {
         T * ret = px;
         px = 0;
         return ret;
     }
 
-    T & operator*() const
+    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const
+    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
@@ -203,7 +203,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT
+    void swap(intrusive_ptr & rhs) BOOST_SP_NOEXCEPT
     {
         T * tmp = px;
         px = rhs.px;
@@ -215,32 +215,32 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a != b.get();
 }
@@ -249,7 +249,7 @@ template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -258,41 +258,41 @@ template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_p
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p)
+template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
@@ -351,7 +351,7 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return boost::hash< T* >()( p.get() );
 }
diff --git a/boost/type_index/ctti_type_index.hpp b/boost/type_index/ctti_type_index.hpp
index 611ad92..6832ade 100644
--- a/boost/type_index/ctti_type_index.hpp
+++ b/boost/type_index/ctti_type_index.hpp
@@ -22,6 +22,7 @@
 #include <boost/type_index/detail/compile_time_type_info.hpp>
 
 #include <cstring>
+#include <boost/functional/hash.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
diff --git a/boost/type_index/detail/compile_time_type_info.hpp b/boost/type_index/detail/compile_time_type_info.hpp
index a2a89ae..4eb2017 100644
--- a/boost/type_index/detail/compile_time_type_info.hpp
+++ b/boost/type_index/detail/compile_time_type_info.hpp
@@ -11,7 +11,7 @@
 
 /// \file compile_time_type_info.hpp
 /// \brief Contains helper macros and implementation details of boost::typeindex::ctti_type_index.
-/// Not intended for inclusion from user's code. 
+/// Not intended for inclusion from user's code.
 
 #include <boost/config.hpp>
 #include <boost/static_assert.hpp>
@@ -59,9 +59,12 @@
     // sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "int>::n() [T = int"
     // note: checked on 3.1, 3.4
     BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ")
-#elif defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
-    // sizeof("static contexpr char boost::detail::ctti<T>::s() [with unsigned int I = 0u; T = ") - 1, sizeof("]") - 1
+#elif defined(__GNUC__) && (__GNUC__ < 7) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+    // sizeof("static constexpr char boost::detail::ctti<T>::s() [with unsigned int I = 0u; T = ") - 1, sizeof("]") - 1
     BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(81, 1, false, "")
+#elif defined(__GNUC__) && (__GNUC__ >= 7) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+    // sizeof("static constexpr char boost::detail::ctti<T>::s() [with unsigned int I = 0; T = ") - 1, sizeof("]") - 1
+    BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(80, 1, false, "")
 #elif defined(__GNUC__) && defined(BOOST_NO_CXX14_CONSTEXPR)
     // sizeof("static const char* boost::detail::ctti<T>::n() [with T = ") - 1, sizeof("]") - 1
     BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(57, 1, false, "")
@@ -72,7 +75,7 @@
 
 #undef BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS
 
-namespace boost { namespace typeindex { namespace detail { 
+namespace boost { namespace typeindex { namespace detail {
     template <bool Condition>
     BOOST_CXX14_CONSTEXPR inline void assert_compile_time_legths() BOOST_NOEXCEPT {
         BOOST_STATIC_ASSERT_MSG(
@@ -149,7 +152,7 @@ namespace boost { namespace typeindex { namespace detail {
     BOOST_CXX14_CONSTEXPR inline const char* skip_begining(const char* begin) BOOST_NOEXCEPT {
         assert_compile_time_legths<(ArrayLength > ctti_skip_size_at_begin + ctti_skip_size_at_end)>();
         return skip_begining_runtime<ArrayLength - ctti_skip_size_at_begin>(
-            begin + ctti_skip_size_at_begin, 
+            begin + ctti_skip_size_at_begin,
             boost::mpl::bool_<ctti_skip_more_at_runtime>()
         );
     }
@@ -203,7 +206,7 @@ namespace boost { namespace detail {
 /// This name must be as short as possible, to avoid code bloat
 template <class T>
 struct ctti {
-   
+
 #if !defined(__clang__) && defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
     //helper functions
     template <unsigned int I>
@@ -286,4 +289,3 @@ struct ctti {
 }} // namespace boost::detail
 
 #endif // BOOST_TYPE_INDEX_DETAIL_COMPILE_TIME_TYPE_INFO_HPP
-
diff --git a/boost/type_index/stl_type_index.hpp b/boost/type_index/stl_type_index.hpp
index be28889..dcc532d 100644
--- a/boost/type_index/stl_type_index.hpp
+++ b/boost/type_index/stl_type_index.hpp
@@ -40,6 +40,12 @@
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
 
+#if !((defined(_MSC_VER) && _MSC_VER > 1600) \
+    || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \
+    || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103 ))
+#   include <boost/functional/hash.hpp>
+#endif
+
 #if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
         || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
 #   include <boost/type_traits/is_signed.hpp>
@@ -174,7 +180,9 @@ inline std::string stl_type_index::pretty_name() const {
 
 
 inline std::size_t stl_type_index::hash_code() const BOOST_NOEXCEPT {
-#if (defined(_MSC_VER) && _MSC_VER > 1600) || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#if (defined(_MSC_VER) && _MSC_VER > 1600) \
+    || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \
+    || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103)
     return data_->hash_code();
 #else
     return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));
diff --git a/boost/type_index/type_index_facade.hpp b/boost/type_index/type_index_facade.hpp
index dd35df2..110000c 100644
--- a/boost/type_index/type_index_facade.hpp
+++ b/boost/type_index/type_index_facade.hpp
@@ -103,7 +103,8 @@ public:
 
     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
     /// \return Hash code of a type. By default hashes types by raw_name().
-    /// \note <boost/functional/hash.hpp> has to be included if this function is used.
+    /// \note Derived class header \b must include <boost/functional/hash.hpp>, \b unless this function is redefined in
+    /// Derived class to not use boost::hash_range().
     inline std::size_t hash_code() const BOOST_NOEXCEPT {
         const char* const name_raw = derived().raw_name();
         return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
diff --git a/boost/type_traits.hpp b/boost/type_traits.hpp
index 93a992d..dbc8c95 100644
--- a/boost/type_traits.hpp
+++ b/boost/type_traits.hpp
@@ -136,6 +136,7 @@
 #include <boost/type_traits/remove_bounds.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_cv_ref.hpp>
 #include <boost/type_traits/remove_extent.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/type_traits/remove_reference.hpp>
diff --git a/boost/type_traits/add_const.hpp b/boost/type_traits/add_const.hpp
index a9fb781..2d60118 100644
--- a/boost/type_traits/add_const.hpp
+++ b/boost/type_traits/add_const.hpp
@@ -41,6 +41,12 @@ namespace boost {
       typedef T& type;
    };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_const_t = typename add_const<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CONST_HPP_INCLUDED
diff --git a/boost/type_traits/add_cv.hpp b/boost/type_traits/add_cv.hpp
index e62ddee..425d019 100644
--- a/boost/type_traits/add_cv.hpp
+++ b/boost/type_traits/add_cv.hpp
@@ -36,6 +36,12 @@ template <class T> struct add_cv{ typedef T const volatile type; };
 
 template <class T> struct add_cv<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_cv_t = typename add_cv<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CV_HPP_INCLUDED
diff --git a/boost/type_traits/add_lvalue_reference.hpp b/boost/type_traits/add_lvalue_reference.hpp
index 41851a1..26b74e6 100644
--- a/boost/type_traits/add_lvalue_reference.hpp
+++ b/boost/type_traits/add_lvalue_reference.hpp
@@ -22,6 +22,12 @@ template <class T> struct add_lvalue_reference<T&&>
 };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+#endif
+
 }
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP
diff --git a/boost/type_traits/add_pointer.hpp b/boost/type_traits/add_pointer.hpp
index 745f63a..85ad33a 100644
--- a/boost/type_traits/add_pointer.hpp
+++ b/boost/type_traits/add_pointer.hpp
@@ -56,6 +56,12 @@ struct add_pointer
 
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED
diff --git a/boost/type_traits/add_reference.hpp b/boost/type_traits/add_reference.hpp
index 3c91415..33e9bc7 100644
--- a/boost/type_traits/add_reference.hpp
+++ b/boost/type_traits/add_reference.hpp
@@ -54,6 +54,13 @@ template <> struct add_reference<const volatile void> { typedef const volatile v
 template <> struct add_reference<volatile void> { typedef volatile void type; };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using add_reference_t = typename add_reference<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/boost/type_traits/add_rvalue_reference.hpp b/boost/type_traits/add_rvalue_reference.hpp
index 44ead34..ad64894 100644
--- a/boost/type_traits/add_rvalue_reference.hpp
+++ b/boost/type_traits/add_rvalue_reference.hpp
@@ -58,6 +58,12 @@ template <class T> struct add_rvalue_reference
    typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+#endif
+
 }  // namespace boost
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
diff --git a/boost/type_traits/add_volatile.hpp b/boost/type_traits/add_volatile.hpp
index 24f515c..253751a 100644
--- a/boost/type_traits/add_volatile.hpp
+++ b/boost/type_traits/add_volatile.hpp
@@ -35,6 +35,12 @@ template <class T> struct add_volatile{ typedef T volatile type; };
 
 template <class T> struct add_volatile<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
diff --git a/boost/type_traits/conditional.hpp b/boost/type_traits/conditional.hpp
index b7e82db..5890198 100644
--- a/boost/type_traits/conditional.hpp
+++ b/boost/type_traits/conditional.hpp
@@ -14,6 +14,12 @@ namespace boost {
 template <bool b, class T, class U> struct conditional { typedef T type; };
 template <class T, class U> struct conditional<false, T, U> { typedef U type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+
+#endif
+
 } // namespace boost
 
 
diff --git a/boost/type_traits/copy_cv.hpp b/boost/type_traits/copy_cv.hpp
index 1605ca3..2f3dc37 100644
--- a/boost/type_traits/copy_cv.hpp
+++ b/boost/type_traits/copy_cv.hpp
@@ -29,6 +29,12 @@ public:
     typedef typename boost::conditional<boost::is_volatile<U>::value, typename boost::add_volatile<CT>::type, CT>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // #ifndef BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED
diff --git a/boost/type_traits/decay.hpp b/boost/type_traits/decay.hpp
index 4e81184..5b28d05 100644
--- a/boost/type_traits/decay.hpp
+++ b/boost/type_traits/decay.hpp
@@ -37,6 +37,12 @@ namespace boost
        typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
     };
     
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using decay_t = typename decay<T>::type;
+
+#endif
+
 } // namespace boost
 
 
diff --git a/boost/type_traits/floating_point_promotion.hpp b/boost/type_traits/floating_point_promotion.hpp
index 993e14e..0e709b7 100644
--- a/boost/type_traits/floating_point_promotion.hpp
+++ b/boost/type_traits/floating_point_promotion.hpp
@@ -14,6 +14,12 @@ namespace boost {
    template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
    template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
diff --git a/boost/type_traits/integral_promotion.hpp b/boost/type_traits/integral_promotion.hpp
index 0478f56..526f90c 100644
--- a/boost/type_traits/integral_promotion.hpp
+++ b/boost/type_traits/integral_promotion.hpp
@@ -175,6 +175,12 @@ public:
    typedef typename boost::type_traits::detail::integral_promotion<T, tag_type::value>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using integral_promotion_t = typename integral_promotion<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
diff --git a/boost/type_traits/make_signed.hpp b/boost/type_traits/make_signed.hpp
index 0d2d5df..6d8b1fb 100644
--- a/boost/type_traits/make_signed.hpp
+++ b/boost/type_traits/make_signed.hpp
@@ -125,6 +125,12 @@ public:
    >::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using make_signed_t = typename make_signed<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/boost/type_traits/make_unsigned.hpp b/boost/type_traits/make_unsigned.hpp
index 4b21eba..17a8a5b 100644
--- a/boost/type_traits/make_unsigned.hpp
+++ b/boost/type_traits/make_unsigned.hpp
@@ -124,6 +124,12 @@ public:
    >::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using make_unsigned_t = typename make_unsigned<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/boost/type_traits/promote.hpp b/boost/type_traits/promote.hpp
index 587617a..1678e1c 100644
--- a/boost/type_traits/promote.hpp
+++ b/boost/type_traits/promote.hpp
@@ -14,6 +14,12 @@ namespace boost {
 
 template<class T> struct promote : public integral_promotion<typename floating_point_promotion<T>::type>{};
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using promote_t = typename promote<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_promote_hpp_INCLUDED
diff --git a/boost/type_traits/remove_all_extents.hpp b/boost/type_traits/remove_all_extents.hpp
index 90c90d3..b9736db 100644
--- a/boost/type_traits/remove_all_extents.hpp
+++ b/boost/type_traits/remove_all_extents.hpp
@@ -30,6 +30,12 @@ template <class T> struct remove_all_extents<T const volatile[]> : public remove
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_all_extents_t = typename remove_all_extents<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/boost/type_traits/remove_bounds.hpp b/boost/type_traits/remove_bounds.hpp
index 56988d2..cd0565d 100644
--- a/boost/type_traits/remove_bounds.hpp
+++ b/boost/type_traits/remove_bounds.hpp
@@ -16,6 +16,13 @@ namespace boost
 
 template <class T> struct remove_bounds : public remove_extent<T> {};
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using remove_bounds_t = typename remove_bounds<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/boost/type_traits/remove_const.hpp b/boost/type_traits/remove_const.hpp
index e238962..6f1a193 100644
--- a/boost/type_traits/remove_const.hpp
+++ b/boost/type_traits/remove_const.hpp
@@ -28,6 +28,12 @@ namespace boost {
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_const_t = typename remove_const<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_CONST_HPP_INCLUDED
diff --git a/boost/type_traits/remove_cv.hpp b/boost/type_traits/remove_cv.hpp
index 08393cf..57a96f2 100644
--- a/boost/type_traits/remove_cv.hpp
+++ b/boost/type_traits/remove_cv.hpp
@@ -34,6 +34,11 @@ template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_cv_t = typename remove_cv<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/boost/type_traits/remove_cv_ref.hpp b/boost/type_traits/remove_cv_ref.hpp
new file mode 100644
index 0000000..118945a
--- /dev/null
+++ b/boost/type_traits/remove_cv_ref.hpp
@@ -0,0 +1,30 @@
+
+//  (C) Copyright Peter Dimov 2017. 
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+
+#ifndef BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
+#define BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost {
+
+   template <class T> struct remove_cv_ref: remove_cv<typename remove_reference<T>::type> {};
+
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_cv_ref_t = typename remove_cv_ref<T>::type;
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
diff --git a/boost/type_traits/remove_extent.hpp b/boost/type_traits/remove_extent.hpp
index b6528e5..55d5730 100644
--- a/boost/type_traits/remove_extent.hpp
+++ b/boost/type_traits/remove_extent.hpp
@@ -30,6 +30,12 @@ template <typename T> struct remove_extent<T const volatile[]> { typedef T const
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_extent_t = typename remove_extent<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/boost/type_traits/remove_pointer.hpp b/boost/type_traits/remove_pointer.hpp
index 9216652..a7baa76 100644
--- a/boost/type_traits/remove_pointer.hpp
+++ b/boost/type_traits/remove_pointer.hpp
@@ -72,6 +72,12 @@ template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };
 
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_pointer_t = typename remove_pointer<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_POINTER_HPP_INCLUDED
diff --git a/boost/type_traits/remove_reference.hpp b/boost/type_traits/remove_reference.hpp
index f75e677..70949fb 100644
--- a/boost/type_traits/remove_reference.hpp
+++ b/boost/type_traits/remove_reference.hpp
@@ -48,6 +48,11 @@ template <class T> struct remove_reference<T&volatile>{ typedef T type; };
 template <class T> struct remove_reference<T&const volatile>{ typedef T type; };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_reference_t = typename remove_reference<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/boost/type_traits/remove_volatile.hpp b/boost/type_traits/remove_volatile.hpp
index f5870f3..bf2c557 100644
--- a/boost/type_traits/remove_volatile.hpp
+++ b/boost/type_traits/remove_volatile.hpp
@@ -28,6 +28,11 @@ namespace boost {
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_volatile_t = typename remove_volatile<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/boost/type_traits/same_traits.hpp b/boost/type_traits/same_traits.hpp
new file mode 100644
index 0000000..dab7dac
--- /dev/null
+++ b/boost/type_traits/same_traits.hpp
@@ -0,0 +1,15 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+//
+//  defines is_same:
+
+#ifndef BOOST_TT_SAME_TRAITS_HPP_INCLUDED
+#define BOOST_TT_SAME_TRAITS_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#endif  // BOOST_TT_SAME_TRAITS_HPP_INCLUDED
diff --git a/boost/type_traits/type_identity.hpp b/boost/type_traits/type_identity.hpp
index 6d2dd5b..73cb3f3 100644
--- a/boost/type_traits/type_identity.hpp
+++ b/boost/type_traits/type_identity.hpp
@@ -17,6 +17,13 @@ template<class T> struct type_identity
     typedef T type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using type_identity_t = typename type_identity<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // #ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED
diff --git a/boost/variant/detail/apply_visitor_binary.hpp b/boost/variant/detail/apply_visitor_binary.hpp
index 6670cd8..e4abf88 100644
--- a/boost/variant/detail/apply_visitor_binary.hpp
+++ b/boost/variant/detail/apply_visitor_binary.hpp
@@ -4,7 +4,7 @@
 //-----------------------------------------------------------------------------
 //
 // Copyright (c) 2002-2003 Eric Friedman
-// Copyright (c) 2014 Antony Polukhin
+// Copyright (c) 2014-2017 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -19,17 +19,24 @@
 
 #include <boost/variant/detail/apply_visitor_unary.hpp>
 
-#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
 #include <boost/utility/enable_if.hpp>
+
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
 #include <boost/mpl/not.hpp>
 #include <boost/type_traits/is_const.hpp>
 #endif
 
-
 #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
 #   include <boost/variant/detail/has_result_type.hpp>
 #endif
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#   include <boost/type_traits/is_lvalue_reference.hpp>
+#   include <boost/type_traits/is_same.hpp>
+#   include <boost/move/move.hpp>
+#   include <boost/move/utility.hpp>
+#endif
+
 namespace boost {
 
 //////////////////////////////////////////////////////////////////////////
@@ -42,7 +49,7 @@ namespace boost {
 
 namespace detail { namespace variant {
 
-template <typename Visitor, typename Value1>
+template <typename Visitor, typename Value1, bool MoveSemantics>
 class apply_visitor_binary_invoke
 {
 public: // visitor typedefs
@@ -65,6 +72,24 @@ public: // structors
 
 public: // visitor interfaces
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    template <typename Value2>
+        typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    operator()(Value2&& value2)
+    {
+        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
+    }
+
+    template <typename Value2>
+        typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    operator()(Value2&& value2)
+    {
+        return visitor_(value1_, ::boost::forward<Value2>(value2));
+    }
+
+#else
+
     template <typename Value2>
         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
     operator()(Value2& value2)
@@ -72,11 +97,13 @@ public: // visitor interfaces
         return visitor_(value1_, value2);
     }
 
+#endif
+
 private:
     apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
 };
 
-template <typename Visitor, typename Visitable2>
+template <typename Visitor, typename Visitable2, bool MoveSemantics>
 class apply_visitor_binary_unwrap
 {
 public: // visitor typedefs
@@ -99,6 +126,36 @@ public: // structors
 
 public: // visitor interfaces
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    template <typename Value1>
+        typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    operator()(Value1&& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
+    }
+
+    template <typename Value1>
+        typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    operator()(Value1&& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+#else
+
     template <typename Value1>
         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
     operator()(Value1& value1)
@@ -106,11 +163,14 @@ public: // visitor interfaces
         apply_visitor_binary_invoke<
               Visitor
             , Value1
+            , false
             > invoker(visitor_, value1);
 
         return boost::apply_visitor(invoker, visitable2_);
     }
 
+#endif
+
 private:
     apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);
 
@@ -139,44 +199,76 @@ private:
 
 #endif // EDG-based compilers workaround
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
 template <typename Visitor, typename Visitable1, typename Visitable2>
 inline
     BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
-apply_visitor(
-      Visitor& visitor
-    , Visitable1& visitable1, Visitable2& visitable2
-    )
+apply_visitor( Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2)
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap<
-          Visitor, Visitable2
+          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+#else
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor( Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2, false
         > unwrapper(visitor, visitable2);
 
     return boost::apply_visitor(unwrapper, visitable1);
 }
 
+#endif
+
 #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
 
 //
 // const-visitor version:
 //
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
 template <typename Visitor, typename Visitable1, typename Visitable2>
 inline
     BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
           typename Visitor::result_type
         )
-apply_visitor(
-      const Visitor& visitor
-    , Visitable1& visitable1, Visitable2& visitable2
-    )
+apply_visitor( const Visitor& visitor , Visitable1&& visitable1 , Visitable2&& visitable2)
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap<
-          const Visitor, Visitable2
+          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
+}
+
+#else
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+          typename Visitor::result_type
+        )
+apply_visitor( const Visitor& visitor , Visitable1& visitable1 , Visitable2& visitable2)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2, false
         > unwrapper(visitor, visitable2);
 
     return boost::apply_visitor(unwrapper, visitable1);
 }
 
+#endif
+
 
 #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
 
@@ -188,7 +280,7 @@ apply_visitor(
 
 namespace detail { namespace variant {
 
-template <typename Visitor, typename Value1>
+template <typename Visitor, typename Value1, bool MoveSemantics>
 class apply_visitor_binary_invoke_cpp14
 {
     Visitor& visitor_;
@@ -205,16 +297,22 @@ public: // structors
 public: // visitor interfaces
 
     template <typename Value2>
-    decltype(auto) operator()(Value2& value2)
+    decltype(auto) operator()(Value2&& value2, typename enable_if_c<MoveSemantics && is_same<Value2, Value2>::value>::type* = 0)
     {
-        return visitor_(value1_, value2);
+        return visitor_(::boost::move(value1_), ::boost::forward<Value2>(value2));
+    }
+
+    template <typename Value2>
+    decltype(auto) operator()(Value2&& value2, typename disable_if_c<MoveSemantics && is_same<Value2, Value2>::value>::type* = 0)
+    {
+        return visitor_(value1_, ::boost::forward<Value2>(value2));
     }
 
 private:
     apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&);
 };
 
-template <typename Visitor, typename Visitable2>
+template <typename Visitor, typename Visitable2, bool MoveSemantics>
 class apply_visitor_binary_unwrap_cpp14
 {
     Visitor& visitor_;
@@ -231,11 +329,24 @@ public: // structors
 public: // visitor interfaces
 
     template <typename Value1>
-    decltype(auto) operator()(Value1& value1)
+    decltype(auto) operator()(Value1&& value1, typename enable_if_c<MoveSemantics && is_same<Value1, Value1>::value>::type* = 0)
     {
         apply_visitor_binary_invoke_cpp14<
               Visitor
             , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, ::boost::move(visitable2_));
+    }
+
+    template <typename Value1>
+    decltype(auto) operator()(Value1&& value1, typename disable_if_c<MoveSemantics && is_same<Value1, Value1>::value>::type* = 0)
+    {
+        apply_visitor_binary_invoke_cpp14<
+              Visitor
+            , Value1
+            , ! ::boost::is_lvalue_reference<Value1>::value
             > invoker(visitor_, value1);
 
         return boost::apply_visitor(invoker, visitable2_);
@@ -248,31 +359,32 @@ private:
 }} // namespace detail::variant
 
 template <typename Visitor, typename Visitable1, typename Visitable2>
-inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2,
+inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
     typename boost::disable_if<
         boost::detail::variant::has_result_type<Visitor>
     >::type* = 0)
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
-          Visitor, Visitable2
+          Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
         > unwrapper(visitor, visitable2);
 
-    return boost::apply_visitor(unwrapper, visitable1);
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
 }
 
 template <typename Visitor, typename Visitable1, typename Visitable2>
-inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2,
+inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1&& visitable1, Visitable2&& visitable2,
     typename boost::disable_if<
         boost::detail::variant::has_result_type<Visitor>
     >::type* = 0)
 {
     ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
-          const Visitor, Visitable2
+          const Visitor, Visitable2, ! ::boost::is_lvalue_reference<Visitable2>::value
         > unwrapper(visitor, visitable2);
 
-    return boost::apply_visitor(unwrapper, visitable1);
+    return boost::apply_visitor(unwrapper, ::boost::forward<Visitable1>(visitable1));
 }
 
+
 #endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
 
 } // namespace boost
diff --git a/boost/variant/detail/apply_visitor_unary.hpp b/boost/variant/detail/apply_visitor_unary.hpp
index d4e2c16..09f70a0 100644
--- a/boost/variant/detail/apply_visitor_unary.hpp
+++ b/boost/variant/detail/apply_visitor_unary.hpp
@@ -16,11 +16,13 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/move/utility.hpp>
 
 #if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
 #include <boost/core/enable_if.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #endif
 
 #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
@@ -62,6 +64,15 @@ namespace boost {
 
 #endif // EDG-based compilers workaround
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(Visitor& visitor, Visitable&& visitable)
+{
+    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
+}
+#else
 template <typename Visitor, typename Visitable>
 inline
     BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
@@ -69,6 +80,7 @@ apply_visitor(Visitor& visitor, Visitable& visitable)
 {
     return visitable.apply_visitor(visitor);
 }
+#endif
 
 #undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
 
@@ -76,6 +88,15 @@ apply_visitor(Visitor& visitor, Visitable& visitable)
 // const-visitor version:
 //
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+apply_visitor(const Visitor& visitor, Visitable&& visitable)
+{
+    return ::boost::forward<Visitable>(visitable).apply_visitor(visitor);
+}
+#else
 template <typename Visitor, typename Visitable>
 inline
     BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
@@ -83,6 +104,7 @@ apply_visitor(const Visitor& visitor, Visitable& visitable)
 {
     return visitable.apply_visitor(visitor);
 }
+#endif
 
 
 #if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
@@ -139,33 +161,34 @@ struct result_wrapper1
     {}
 
     template <class T>
-    result_type operator()(T& val) const {
-        return visitor_(val);
+    result_type operator()(T&& val) const {
+        return visitor_(::boost::forward<T>(val));
     }
 };
 
 }} // namespace detail::variant
 
 template <typename Visitor, typename Visitable>
-inline decltype(auto) apply_visitor(Visitor& visitor, Visitable& visitable,
+inline decltype(auto) apply_visitor(Visitor& visitor, Visitable&& visitable,
     typename boost::disable_if<
         boost::detail::variant::has_result_type<Visitor>
     >::type* = 0)
 {
-    boost::detail::variant::result_wrapper1<Visitor, Visitable> cpp14_vis(visitor);
-    return visitable.apply_visitor(cpp14_vis);
+    boost::detail::variant::result_wrapper1<Visitor, typename remove_reference<Visitable>::type> cpp14_vis(visitor);
+    return ::boost::forward<Visitable>(visitable).apply_visitor(cpp14_vis);
 }
 
 template <typename Visitor, typename Visitable>
-inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable& visitable,
+inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable&& visitable,
     typename boost::disable_if<
         boost::detail::variant::has_result_type<Visitor>
     >::type* = 0)
 {
-    boost::detail::variant::result_wrapper1<const Visitor, Visitable> cpp14_vis(visitor);
-    return visitable.apply_visitor(cpp14_vis);
+    boost::detail::variant::result_wrapper1<const Visitor, typename remove_reference<Visitable>::type> cpp14_vis(visitor);
+    return ::boost::forward<Visitable>(visitable).apply_visitor(cpp14_vis);
 }
 
+
 #endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
 
 } // namespace boost
diff --git a/boost/variant/detail/multivisitors_cpp11_based.hpp b/boost/variant/detail/multivisitors_cpp11_based.hpp
index f9286b7..56aaf12 100644
--- a/boost/variant/detail/multivisitors_cpp11_based.hpp
+++ b/boost/variant/detail/multivisitors_cpp11_based.hpp
@@ -18,6 +18,9 @@
 
 #include <boost/variant/detail/apply_visitor_unary.hpp>
 #include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#include <boost/move/utility.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+#include <boost/core/enable_if.hpp>
 
 #if defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_HDR_TUPLE)
 #   error "This file requires <tuple> and variadic templates support"
@@ -41,10 +44,34 @@ namespace detail { namespace variant {
         : index_sequence<I...> 
     {};
 
-    template <class... Types>
-    std::tuple<Types&...> forward_as_tuple_simple(Types&... args) BOOST_NOEXCEPT
+    template <typename T_, bool MoveSemantics_>
+    struct MoveableWrapper //Just a reference with some metadata
     {
-        return std::tuple<Types&...>(args...);
+        typedef T_ T;
+        static constexpr bool MoveSemantics = MoveSemantics_;
+
+        T& v;
+    };
+
+    template <typename Tp, bool MoveSemantics>
+    MoveableWrapper<Tp, MoveSemantics>
+        wrap(Tp& t)
+    {
+        return MoveableWrapper<Tp, MoveSemantics>{t};
+    }
+
+    template <typename Wrapper>
+    typename enable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type
+        unwrap(Wrapper& w)
+    {
+        return ::boost::move(w.v);
+    }
+
+    template <typename Wrapper>
+    typename disable_if_c<Wrapper::MoveSemantics, typename Wrapper::T>::type &
+        unwrap(Wrapper& w)
+    {
+        return w.v;
     }
 
     // Implementing some of the helper tuple methods
@@ -64,7 +91,6 @@ namespace detail { namespace variant {
     }
 
 
-
     // Forward declaration
     template <typename Visitor, typename Visitables, typename... Values>
     class one_by_one_visitor_and_value_referer;
@@ -72,7 +98,7 @@ namespace detail { namespace variant {
     template <typename Visitor, typename Visitables, typename... Values>
     inline one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... >
         make_one_by_one_visitor_and_value_referer(
-            Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
         )
     {
         return one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... > (
@@ -84,12 +110,12 @@ namespace detail { namespace variant {
     class one_by_one_visitor_and_value_referer
     {
         Visitor&                        visitor_;
-        std::tuple<Values&...>          values_;
+        std::tuple<Values...>           values_;
         Visitables                      visitables_;
 
     public: // structors
         one_by_one_visitor_and_value_referer(
-                    Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
                 ) BOOST_NOEXCEPT
             : visitor_(visitor)
             , values_(values)
@@ -100,15 +126,15 @@ namespace detail { namespace variant {
         typedef typename Visitor::result_type result_type;
 
         template <typename Value>
-        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value& value) const
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value&& value) const
         {
             return ::boost::apply_visitor(
                 make_one_by_one_visitor_and_value_referer(
                     visitor_,
                     tuple_tail(visitables_),
-                    std::tuple_cat(values_, std::tuple<Value&>(value))
+                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
                 )
-                , std::get<0>(visitables_) // getting Head element
+                , unwrap(std::get<0>(visitables_)) // getting Head element
             );
         }
 
@@ -120,11 +146,11 @@ namespace detail { namespace variant {
     class one_by_one_visitor_and_value_referer<Visitor, std::tuple<>, Values...>
     {
         Visitor&                        visitor_;
-        std::tuple<Values&...>          values_;
+        std::tuple<Values...>           values_;
 
     public:
         one_by_one_visitor_and_value_referer(
-                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values&...> values
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
                 ) BOOST_NOEXCEPT
             : visitor_(visitor)
             , values_(values)
@@ -134,14 +160,14 @@ namespace detail { namespace variant {
 
         template <class Tuple, std::size_t... I>
         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) do_call(Tuple t, index_sequence<I...>) const {
-            return visitor_(std::get<I>(t)...);
+            return visitor_(unwrap(std::get<I>(t))...);
         }
 
         template <typename Value>
-        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value& value) const
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value&& value) const
         {
             return do_call(
-                std::tuple_cat(values_, std::tuple<Value&>(value)),
+                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
                 make_index_sequence<sizeof...(Values) + 1>()
             );
         }
@@ -151,30 +177,38 @@ namespace detail { namespace variant {
 
     template <class Visitor, class T1, class T2, class T3, class... TN>
     inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
-        apply_visitor(const Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn)
+        apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
     {
         return ::boost::apply_visitor(
             ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
                 visitor,
-                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
                 std::tuple<>()
-            ),
-            v1
-        );
+                ),
+                ::boost::forward<T1>(v1)
+            );
     }
     
     template <class Visitor, class T1, class T2, class T3, class... TN>
     inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
-        apply_visitor(Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn)
+        apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn)
     {
         return ::boost::apply_visitor(
             ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
                 visitor,
-                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
                 std::tuple<>()
-            ),
-            v1
-        );
+                ),
+                ::boost::forward<T1>(v1)
+            );
     }
 
 } // namespace boost
diff --git a/boost/variant/detail/multivisitors_cpp14_based.hpp b/boost/variant/detail/multivisitors_cpp14_based.hpp
index a2af328..abf03eb 100644
--- a/boost/variant/detail/multivisitors_cpp14_based.hpp
+++ b/boost/variant/detail/multivisitors_cpp14_based.hpp
@@ -30,7 +30,7 @@ namespace detail { namespace variant {
     template <typename Visitor, typename Visitables, typename... Values>
     inline one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... >
         make_one_by_one_visitor_and_value_referer_cpp14(
-            Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+            Visitor& visitor, Visitables visitables, std::tuple<Values...> values
         )
     {
         return one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... > (
@@ -42,12 +42,12 @@ namespace detail { namespace variant {
     class one_by_one_visitor_and_value_referer_cpp14
     {
         Visitor&                        visitor_;
-        std::tuple<Values&...>          values_;
+        std::tuple<Values...>           values_;
         Visitables                      visitables_;
 
     public: // structors
         one_by_one_visitor_and_value_referer_cpp14(
-                    Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+                    Visitor& visitor, Visitables visitables, std::tuple<Values...> values
                 ) BOOST_NOEXCEPT
             : visitor_(visitor)
             , values_(values)
@@ -56,15 +56,15 @@ namespace detail { namespace variant {
 
     public: // visitor interfaces
         template <typename Value>
-        decltype(auto) operator()(Value& value) const
+        decltype(auto) operator()(Value&& value) const
         {
             return ::boost::apply_visitor(
                 make_one_by_one_visitor_and_value_referer_cpp14(
                     visitor_,
                     tuple_tail(visitables_),
-                    std::tuple_cat(values_, std::tuple<Value&>(value))
+                    std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value)))
                 )
-                , std::get<0>(visitables_) // getting Head element
+                , unwrap(std::get<0>(visitables_)) // getting Head element
             );
         }
 
@@ -76,11 +76,11 @@ namespace detail { namespace variant {
     class one_by_one_visitor_and_value_referer_cpp14<Visitor, std::tuple<>, Values...>
     {
         Visitor&                        visitor_;
-        std::tuple<Values&...>          values_;
+        std::tuple<Values...>           values_;
 
     public:
         one_by_one_visitor_and_value_referer_cpp14(
-                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values&...> values
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values...> values
                 ) BOOST_NOEXCEPT
             : visitor_(visitor)
             , values_(values)
@@ -88,14 +88,14 @@ namespace detail { namespace variant {
 
         template <class Tuple, std::size_t... I>
         decltype(auto) do_call(Tuple t, index_sequence<I...>) const {
-            return visitor_(std::get<I>(t)...);
+            return visitor_(unwrap(std::get<I>(t))...);
         }
 
         template <typename Value>
-        decltype(auto) operator()(Value& value) const
+        decltype(auto) operator()(Value&& value) const
         {
             return do_call(
-                std::tuple_cat(values_, std::tuple<Value&>(value)),
+                std::tuple_cat(values_, std::make_tuple(wrap<Value, ! ::boost::is_lvalue_reference<Value>::value>(value))),
                 make_index_sequence<sizeof...(Values) + 1>()
             );
         }
@@ -104,7 +104,7 @@ namespace detail { namespace variant {
 }} // namespace detail::variant
 
     template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline decltype(auto) apply_visitor(const Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn,
+    inline decltype(auto) apply_visitor(const Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
         typename boost::disable_if<
             boost::detail::variant::has_result_type<Visitor>
         >::type* = 0)
@@ -112,16 +112,20 @@ namespace detail { namespace variant {
         return boost::apply_visitor(
             ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
                 visitor,
-                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
                 std::tuple<>()
             ),
-            v1
+            ::boost::forward<T1>(v1)
         );
     }
     
 
     template <class Visitor, class T1, class T2, class T3, class... TN>
-    inline decltype(auto) apply_visitor(Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn,
+    inline decltype(auto) apply_visitor(Visitor& visitor, T1&& v1, T2&& v2, T3&& v3, TN&&... vn,
         typename boost::disable_if<
             boost::detail::variant::has_result_type<Visitor>
         >::type* = 0)
@@ -129,10 +133,14 @@ namespace detail { namespace variant {
         return ::boost::apply_visitor(
             ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
                 visitor,
-                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::make_tuple(
+                    ::boost::detail::variant::wrap<T2, ! ::boost::is_lvalue_reference<T2>::value>(v2),
+                    ::boost::detail::variant::wrap<T3, ! ::boost::is_lvalue_reference<T3>::value>(v3),
+                    ::boost::detail::variant::wrap<TN, ! ::boost::is_lvalue_reference<TN>::value>(vn)...
+                    ),
                 std::tuple<>()
             ),
-            v1
+            ::boost::forward<T1>(v1)
         );
     }
 
diff --git a/boost/variant/get.hpp b/boost/variant/get.hpp
index f3eb84d..abce6c4 100644
--- a/boost/variant/get.hpp
+++ b/boost/variant/get.hpp
@@ -22,9 +22,11 @@
 #include <boost/utility/addressof.hpp>
 #include <boost/variant/variant_fwd.hpp>
 #include <boost/variant/detail/element_index.hpp>
+#include <boost/variant/detail/move.hpp>
 
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
 
 namespace boost {
 
@@ -170,7 +172,34 @@ relaxed_get(
     return *result;
 }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 
+#if defined(BOOST_MSVC) && (_MSC_VER < 1900) // MSVC-2014 has fixed the incorrect diagnostics.
+#   pragma warning(push)
+#   pragma warning(disable: 4172) // returning address of local variable or temporary
+#endif
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = relaxed_get<U>(boost::addressof(operand));
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return static_cast<U&&>(*result);
+}
+
+#if defined(BOOST_MSVC) && (_MSC_VER < 1900)
+#   pragma warning(pop)
+#endif
+
+#endif
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // strict_get<U>(variant) methods
@@ -243,6 +272,30 @@ strict_get(
     return relaxed_get<U>(operand);
 }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (!boost::is_lvalue_reference<U>::value),
+        "remove ampersand '&' from template type U in boost::get<U>(boost::variant<T...>&&) "
+    );
+
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception"
+    );
+
+    return relaxed_get<U>(detail::variant::move(operand));
+}
+#endif
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // get<U>(variant) methods
 //
@@ -308,6 +361,23 @@ get(
 #endif
 }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(detail::variant::move(operand));
+#else
+    return strict_get<U>(detail::variant::move(operand));
+#endif
+}
+#endif
+
 } // namespace boost
 
 #endif // BOOST_VARIANT_GET_HPP
diff --git a/boost/variant/polymorphic_get.hpp b/boost/variant/polymorphic_get.hpp
index 1a98382..c4ec0bf 100644
--- a/boost/variant/polymorphic_get.hpp
+++ b/boost/variant/polymorphic_get.hpp
@@ -25,6 +25,7 @@
 #include <boost/type_traits/add_reference.hpp>
 #include <boost/type_traits/add_pointer.hpp>
 #include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_const.hpp>
 
 namespace boost {
 
diff --git a/boost/variant/variant.hpp b/boost/variant/variant.hpp
index 1c64447..2e99fbd 100644
--- a/boost/variant/variant.hpp
+++ b/boost/variant/variant.hpp
@@ -71,10 +71,12 @@
 #include <boost/mpl/front.hpp>
 #include <boost/mpl/identity.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/insert_range.hpp>
 #include <boost/mpl/int.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/iterator_range.hpp>
 #include <boost/mpl/iter_fold_if.hpp>
+#include <boost/mpl/list.hpp>
 #include <boost/mpl/logical.hpp>
 #include <boost/mpl/max_element.hpp>
 #include <boost/mpl/next.hpp>
@@ -386,7 +388,7 @@ public: // visitor interfaces
 
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) || \
     BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
-        operand; // suppresses warnings
+        (void)operand; // suppresses warnings
 #endif
 
         BOOST_VARIANT_AUX_RETURN_VOID;
@@ -1017,7 +1019,7 @@ struct less_comp
 //  * for wrappers (e.g., recursive_wrapper), the wrapper's held value.
 //  * for all other values, the value itself.
 //
-template <typename Visitor>
+template <typename Visitor, bool MoveSemantics>
 class invoke_visitor
 {
 private: // representation
@@ -1040,6 +1042,24 @@ public: // structors
 
 public: // internal visitor interfaces
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+    typename enable_if_c<MoveSemantics && is_same<T, T>::value, result_type>::type internal_visit(T&& operand, int)
+    {
+        return visitor_(::boost::move<T>(operand));
+    }
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+    typename disable_if_c<MoveSemantics && is_same<T, T>::value, result_type>::type internal_visit(T&& operand, int)
+    {
+        return visitor_(operand);
+    }
+
+#else
+
     template <typename T>
     result_type internal_visit(T& operand, int)
     {
@@ -1052,12 +1072,52 @@ public: // internal visitor interfaces
     {
         return visitor_(operand);
     }
-#   endif
+#   endif //BORLAND
+
+#endif //RVALUE REFERENCES
 
 #else // defined(BOOST_NO_VOID_RETURNS)
 
 private: // helpers, for internal visitor interfaces (below)
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+        typename enable_if<mpl::and_<MoveSemantics && is_same<T, T>::value>, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    visit_impl(T&& operand, mpl::false_)
+    {
+        return visitor_(::boost::move(operand));
+    }
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+        typename enable_if_c<MoveSemantics && is_same<T, T>::value, BOOST_VARIANT_AUX_RETURN_VOID_TYPE>::type
+    visit_impl(T&& operand, mpl::true_)
+    {
+        visitor_(::boost::move(operand));
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+        typename disable_if_c<MoveSemantics && is_same<T, T>::value, BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)>::type
+    visit_impl(T&& operand, mpl::false_)
+    {
+        return visitor_(operand);
+    }
+
+    //using workaround with is_same<T, T> to prenvent compilation error, because we need to use T in enable_if to make SFINAE work
+    template <typename T>
+        typename disable_if<MoveSemantics && is_same<T, T>::value, BOOST_VARIANT_AUX_RETURN_VOID_TYPE>::type
+    visit_impl(T&& operand, mpl::true_)
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+#else
+
     template <typename T>
         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
     visit_impl(T& operand, mpl::false_)
@@ -1073,6 +1133,8 @@ private: // helpers, for internal visitor interfaces (below)
         BOOST_VARIANT_AUX_RETURN_VOID;
     }
 
+#endif //RVALUE_REFERENCES
+
 public: // internal visitor interfaces
 
     template <typename T>
@@ -2419,13 +2481,40 @@ public:
 
 public: // visitation support
 
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor) &&
+    {
+        detail::variant::invoke_visitor<Visitor, true> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor) const&&
+    {
+        detail::variant::invoke_visitor<Visitor, true> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+#endif
+
     template <typename Visitor>
         BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
               typename Visitor::result_type
             )
     apply_visitor(Visitor& visitor)
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+    &
+#endif
     {
-        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        detail::variant::invoke_visitor<Visitor, false> invoker(visitor);
         return this->internal_apply_visitor(invoker);
     }
 
@@ -2434,8 +2523,11 @@ public: // visitation support
               typename Visitor::result_type
             )
     apply_visitor(Visitor& visitor) const
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+    &
+#endif
     {
-        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        detail::variant::invoke_visitor<Visitor, false> invoker(visitor);
         return this->internal_apply_visitor(invoker);
     }
 
@@ -2452,16 +2544,20 @@ struct make_variant_over
 private: // precondition assertions
 
     BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value ));
+    typedef typename boost::mpl::insert_range<
+      boost::mpl::list<>
+    , boost::mpl::end< boost::mpl::list<> >::type
+    , Types
+    >::type copied_sequence_t;
 
 public: // metafunction result
 
     typedef variant<
-          detail::variant::over_sequence< Types >
+          detail::variant::over_sequence<copied_sequence_t>
         > type;
 
 };
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // function template swap
 //
diff --git a/boost/version.hpp b/boost/version.hpp
index 03b33f9..d8f2132 100644
--- a/boost/version.hpp
+++ b/boost/version.hpp
@@ -19,7 +19,7 @@
 //  BOOST_VERSION / 100 % 1000 is the minor version
 //  BOOST_VERSION / 100000 is the major version
 
-#define BOOST_VERSION 106400
+#define BOOST_VERSION 106600
 
 //
 //  BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
@@ -27,6 +27,6 @@
 //  number, y is the minor version number, and z is the patch level if not 0.
 //  This is used by <config/auto_link.hpp> to select which library version to link to.
 
-#define BOOST_LIB_VERSION "1_64"
+#define BOOST_LIB_VERSION "1_66"
 
 #endif