Update contrib/restricted/boost/container to 1.85.0

2ca8559c599fde7e465b58c8e9abc13bcdee4a76

27 files changed, 1035 insertions, 981 deletions

diff --git a/contrib/restricted/boost/container/include/boost/container/allocator_traits.hpp b/contrib/restricted/boost/container/include/boost/container/allocator_traits.hpp
index f5f73efa50..cdb6683e88 100644
--- a/contrib/restricted/boost/container/include/boost/container/allocator_traits.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/allocator_traits.hpp
@@ -44,8 +44,6 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
-// other boost
-#include <boost/static_assert.hpp>
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -298,18 +296,18 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.allocate(n)</code>
    //!
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n)
+   inline static pointer allocate(Allocator &a, size_type n)
    {  return a.allocate(n);  }
 
    //! <b>Returns</b>: <code>a.deallocate(p, n)</code>
    //!
    //! <b>Throws</b>: Nothing
-   BOOST_CONTAINER_FORCEINLINE static void deallocate(Allocator &a, pointer p, size_type n)
+   inline static void deallocate(Allocator &a, pointer p, size_type n)
    {  a.deallocate(p, n);  }
 
    //! <b>Effects</b>: calls <code>a.allocate(n, p)</code> if that call is well-formed;
    //! otherwise, invokes <code>a.allocate(n)</code>
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
+   inline static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
    {
       const bool value = boost::container::dtl::
          has_member_function_callable_with_allocate
@@ -321,7 +319,7 @@ struct allocator_traits
    //! <b>Effects</b>: calls <code>a.destroy(p)</code> if that call is well-formed;
    //! otherwise, invokes <code>p->~T()</code>.
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef T* destroy_pointer;
       const bool value = boost::container::dtl::
@@ -333,7 +331,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.max_size()</code> if that expression is well-formed; otherwise,
    //! <code>numeric_limits<size_type>::max()</code>.
-   BOOST_CONTAINER_FORCEINLINE static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
       dtl::bool_<value> flag;
@@ -342,7 +340,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.select_on_container_copy_construction()</code> if that expression is well-formed;
    //! otherwise, a.
-   BOOST_CONTAINER_FORCEINLINE static BOOST_CONTAINER_DOC1ST(Allocator,
+   inline static BOOST_CONTAINER_DOC1ST(Allocator,
       typename dtl::if_c
          < allocator_traits_detail::has_select_on_container_copy_construction<Allocator BOOST_MOVE_I Allocator (Allocator::*)() const>::value
          BOOST_MOVE_I Allocator BOOST_MOVE_I const Allocator & >::type)
@@ -358,7 +356,7 @@ struct allocator_traits
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
       //! 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)
+      inline static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
          static const bool value = ::boost::move_detail::and_
             < dtl::is_not_std_allocator<Allocator>
@@ -372,7 +370,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.storage_is_unpropagable(p)</code> if is_partially_propagable::value is true; otherwise,
    //! <code>false</code>.
-   BOOST_CONTAINER_FORCEINLINE static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       dtl::bool_<is_partially_propagable::value> flag;
       return allocator_traits::priv_storage_is_unpropagable(flag, a, p);
@@ -380,7 +378,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>true</code> if <code>is_always_equal::value == true</code>, otherwise,
    //! <code>a == b</code>.
-   BOOST_CONTAINER_FORCEINLINE static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
    {
       dtl::bool_<is_always_equal::value> flag;
       return allocator_traits::priv_equal(flag, a, b);
@@ -388,46 +386,46 @@ struct allocator_traits
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    private:
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
+   inline static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
    {  return a.allocate(n, p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
+   inline static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
    {  return a.allocate(n);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  a.destroy(p);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  p->~T(); (void)p;  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a.max_size();  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/sizeof(value_type);  }
 
-   BOOST_CONTAINER_FORCEINLINE static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
+   inline static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
    {  return a.select_on_container_copy_construction();  }
 
-   BOOST_CONTAINER_FORCEINLINE static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   inline static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a;  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
+      inline static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
       {  a.construct( p, ::boost::forward<Args>(args)...);  }
 
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
+      inline static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
       {  ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       public:
 
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {\
          static const bool value = ::boost::move_detail::and_ \
             < dtl::is_not_std_allocator<Allocator> \
@@ -447,11 +445,11 @@ struct allocator_traits
       /////////////////////////////////
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  a.construct( p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );  }\
       \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      inline static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL)
@@ -460,19 +458,19 @@ struct allocator_traits
    #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
+   inline static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
    {  ::new((void*)p, boost_container_new_t()) T; }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
+   inline static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
    {  return a.storage_is_unpropagable(p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
+   inline static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
    {  return false;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::true_type,  const Allocator &, const Allocator &)
+   inline static bool priv_equal(dtl::true_type,  const Allocator &, const Allocator &)
    {  return true;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
+   inline static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
    {  return a == b;  }
 
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/advanced_insert_int.hpp b/contrib/restricted/boost/container/include/boost/container/detail/advanced_insert_int.hpp
index 0238805db2..bc6801adb4 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/advanced_insert_int.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/advanced_insert_int.hpp
@@ -49,19 +49,19 @@ struct move_insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
+   inline explicit move_insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_move_alloc_n_source
          (a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::move_n_source(this->first_, n, p);
    }
@@ -75,18 +75,18 @@ struct insert_range_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
+   inline explicit insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
    }
@@ -100,16 +100,16 @@ struct insert_n_copies_proxy
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
+   inline explicit insert_n_copies_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -129,7 +129,7 @@ struct insert_value_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -155,7 +155,7 @@ struct insert_default_initialized_n_proxy
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
    template<class Iterator>
@@ -183,19 +183,19 @@ struct insert_copy_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_copy_proxy(const value_type &v)
+   inline explicit insert_copy_proxy(const value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = v_;
@@ -213,19 +213,19 @@ struct insert_move_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_move_proxy(value_type &v)
+   inline explicit insert_move_proxy(value_type &v)
       :  v_(v)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
+   inline void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -235,13 +235,13 @@ struct insert_move_proxy
 };
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
+inline insert_move_proxy<Allocator> get_insert_value_proxy(BOOST_RV_REF(typename boost::container::iterator_traits<It>::value_type) v)
 {
    return insert_move_proxy<Allocator>(v);
 }
 
 template<class It, class Allocator>
-BOOST_CONTAINER_FORCEINLINE insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
+inline insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
 {
    return insert_copy_proxy<Allocator>(v);
 }
@@ -266,17 +266,17 @@ struct insert_nonmovable_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : args_(args...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n == 1); (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
@@ -297,18 +297,18 @@ struct insert_emplace_proxy
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
+   inline explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : base_t(::boost::forward<Args>(args)...)
    {}
 
    template<class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
 
    template<std::size_t ...IdxPack, class Iterator>
-   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
+   inline void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
@@ -333,7 +333,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -350,7 +350,7 @@ struct insert_emplace_proxy<Allocator
 
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -361,7 +361,7 @@ struct insert_emplace_proxy<Allocator, typename boost::container::allocator_trai
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -374,7 +374,7 @@ struct insert_emplace_proxy<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -398,18 +398,18 @@ struct insert_nonmovable_emplace_proxy##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
+   inline void copy_n_and_update(Allocator &, Iterator, std::size_t)\
    {  BOOST_ASSERT(false);   }\
    \
    protected:\
@@ -427,11 +427,11 @@ struct insert_emplace_proxy_arg##N\
    \
    static const bool single_value = true;\
    \
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
+   inline explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
    \
    template<class Iterator>\
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
+   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
@@ -461,7 +461,7 @@ struct insert_emplace_proxy_arg1<Allocator, ::boost::rv<typename boost::containe
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -472,7 +472,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -486,7 +486,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
+   inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
    {}
 };
@@ -502,7 +502,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -513,7 +513,7 @@ struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
@@ -526,7 +526,7 @@ struct insert_emplace_proxy_arg1<Allocator
 {
    static const bool single_value = true;
 
-   BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
+   inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
    {}
 };
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/alloc_helpers.hpp b/contrib/restricted/boost/container/include/boost/container/detail/alloc_helpers.hpp
index 5ca2ca727d..57c59e46c1 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/alloc_helpers.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/alloc_helpers.hpp
@@ -27,30 +27,30 @@ namespace container {
 namespace dtl {
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  boost::adl_move_swap(l, r);   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
+inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
+inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
 {  l = r;   }
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
+inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-BOOST_CONTAINER_FORCEINLINE void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
+inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
 }  //namespace dtl {
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/allocator_version_traits.hpp b/contrib/restricted/boost/container/include/boost/container/detail/allocator_version_traits.hpp
index 391f4666cc..4e83d213b1 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/allocator_version_traits.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/allocator_version_traits.hpp
@@ -46,19 +46,19 @@ struct allocator_version_traits
    typedef typename boost::container::allocator_traits<Allocator>::size_type  size_type;
 
    //Node allocation interface
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate_one();   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate_one(p);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
+   inline static void allocate_individual(Allocator &a, size_type n, multiallocation_chain &m)
    {  return a.allocate_individual(n, m);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
+   inline static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
    {  a.deallocate_individual(holder);   }
 
-   BOOST_CONTAINER_FORCEINLINE static pointer allocation_command(Allocator &a, allocation_type command,
+   inline static pointer allocation_command(Allocator &a, allocation_type command,
                          size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {  return a.allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);  }
 };
@@ -82,10 +82,10 @@ struct allocator_version_traits<Allocator, 1>
          < multialloc_cached_counted, value_type>           multiallocation_chain;
 
    //Node allocation interface
-   BOOST_CONTAINER_FORCEINLINE static pointer allocate_one(Allocator &a)
+   inline static pointer allocate_one(Allocator &a)
    {  return a.allocate(1);   }
 
-   BOOST_CONTAINER_FORCEINLINE static void deallocate_one(Allocator &a, const pointer &p)
+   inline static void deallocate_one(Allocator &a, const pointer &p)
    {  a.deallocate(p, 1);   }
 
    static void deallocate_individual(Allocator &a, multiallocation_chain &holder)
@@ -102,17 +102,17 @@ struct allocator_version_traits<Allocator, 1>
 
    struct allocate_individual_rollback
    {
-      BOOST_CONTAINER_FORCEINLINE allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
+      inline allocate_individual_rollback(Allocator &a, multiallocation_chain &chain)
          : mr_a(a), mp_chain(&chain)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE ~allocate_individual_rollback()
+      inline ~allocate_individual_rollback()
       {
          if(mp_chain)
             allocator_version_traits::deallocate_individual(mr_a, *mp_chain);
       }
 
-      BOOST_CONTAINER_FORCEINLINE void release()
+      inline void release()
       {
          mp_chain = 0;
       }
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/compare_functors.hpp b/contrib/restricted/boost/container/include/boost/container/detail/compare_functors.hpp
index ae4ffcea9d..9a35274024 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/compare_functors.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/compare_functors.hpp
@@ -32,11 +32,11 @@ class equal_to_value
    const value_type &t_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit equal_to_value(const value_type &t)
+   inline explicit equal_to_value(const value_type &t)
       :  t_(t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const value_type &t)const
+   inline bool operator()(const value_type &t)const
    {  return t_ == t;   }
 };
 
@@ -47,39 +47,39 @@ struct value_to_node_compare
    typedef Pred predicate_type;
    typedef Node node_type;
 
-   BOOST_CONTAINER_FORCEINLINE value_to_node_compare()
+   inline value_to_node_compare()
       : Pred()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit value_to_node_compare(Pred pred)
+   inline explicit value_to_node_compare(Pred pred)
       :  Pred(pred)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b) const
+   inline Ret operator()(const Node &a, const Node &b) const
    {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a) const
+   inline Ret operator()(const Node &a) const
    {  return static_cast<const Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b)
+   inline Ret operator()(const Node &a, const Node &b)
    {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a)
+   inline Ret operator()(const Node &a)
    {  return static_cast<Pred&>(*this)(a.get_data());  }
 
-   BOOST_CONTAINER_FORCEINLINE predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
-   BOOST_CONTAINER_FORCEINLINE const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
+   inline predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
+   inline const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
 };
 
 template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
 struct key_node_pred
    :  public boost::intrusive::detail::ebo_functor_holder<KeyPred>
 {
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred(const KeyPred &comp)
+   inline explicit key_node_pred(const KeyPred &comp)
       :  base_t(comp)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred()
+   inline explicit key_node_pred()
    {}
 
    typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
@@ -88,42 +88,42 @@ struct key_node_pred
    typedef typename KeyOfValue::type   key_type;
 
 
-   BOOST_CONTAINER_FORCEINLINE static const key_type &key_from(const Node &n)
+   inline static const key_type &key_from(const Node &n)
    {
       return key_of_value()(n.get_data());
    }
 
    template <class T>
-   BOOST_CONTAINER_FORCEINLINE static const T &
+   inline static const T &
       key_from(const T &t)
    {  return t;  }
 
-   BOOST_CONTAINER_FORCEINLINE const key_predicate &key_pred() const
+   inline const key_predicate &key_pred() const
    {  return static_cast<const key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE key_predicate &key_pred()
+   inline key_predicate &key_pred()
    {  return static_cast<key_predicate &>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_pred()(key);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE Ret operator()(const U &nonkey) const
+   inline Ret operator()(const U &nonkey) const
    {  return this->key_pred()(this->key_from(nonkey));  }
 
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   inline bool operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_pred()(key1, key2);  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const key_type &key1, const U &nonkey2) const
+   inline bool operator()(const key_type &key1, const U &nonkey2) const
    {  return this->key_pred()(key1, this->key_from(nonkey2));  }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2) const
+   inline bool operator()(const U &nonkey1, const key_type &key2) const
    {  return this->key_pred()(this->key_from(nonkey1), key2);  }
 
    template<class U, class V>
-   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &nonkey1, const V &nonkey2) const
+   inline bool operator()(const U &nonkey1, const V &nonkey2) const
    {  return this->key_pred()(this->key_from(nonkey1), this->key_from(nonkey2));  }
 };
 
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/copy_move_algo.hpp b/contrib/restricted/boost/container/include/boost/container/detail/copy_move_algo.hpp
index 8729b307bb..105faf606d 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/copy_move_algo.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/copy_move_algo.hpp
@@ -46,7 +46,12 @@
 #  endif
 //GCC 8 seems a bit confused about array access error with static_vector
 //when out of bound exceptions are being thrown.
-#  if defined(BOOST_GCC) && (BOOST_GCC >= 80000) && (BOOST_GCC < 80200)
+#  if defined(BOOST_GCC) && ((BOOST_GCC >= 80000) && (BOOST_GCC < 80200))
+#     pragma GCC diagnostic ignored "-Wstringop-overflow"
+#  endif
+//GCC 12 seems a bit confused about array access error with small_vector
+#  if defined(BOOST_GCC) && ((BOOST_GCC >= 120000) && (BOOST_GCC < 130000))
+#     pragma GCC diagnostic ignored "-Wstringop-overread"
 #     pragma GCC diagnostic ignored "-Wstringop-overflow"
 #  endif
 #  pragma GCC diagnostic ignored "-Warray-bounds"
@@ -214,7 +219,7 @@ struct disable_if_single_value_proxy
 template
    <typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
+inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iter_value<I>::type      value_type;
    typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
@@ -232,7 +237,7 @@ BOOST_CONTAINER_FORCEINLINE F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 template
    <typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE F memmove_n(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+inline F memmove_n(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iter_value<I>::type value_type;
    typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
@@ -250,7 +255,7 @@ BOOST_CONTAINER_FORCEINLINE F memmove_n(I f, std::size_t n, F r) BOOST_NOEXCEPT_
 template
    <typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE I memmove_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+inline I memmove_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    if(BOOST_LIKELY(n != 0)){
       typedef typename boost::container::iter_value<I>::type value_type;
@@ -267,7 +272,7 @@ BOOST_CONTAINER_FORCEINLINE I memmove_n_source(I f, std::size_t n, F r) BOOST_NO
 template
    <typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE I memmove_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+inline I memmove_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iter_value<I>::type value_type;
    typedef typename boost::container::iterator_traits<F>::difference_type i_difference_type;
@@ -367,7 +372,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove(f, l, r); }
 
@@ -413,7 +418,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc_n(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
@@ -459,7 +464,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_move_alloc_n_source(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
@@ -504,7 +509,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove(f, l, r); }
 
@@ -550,7 +555,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc_n(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
@@ -595,7 +600,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_copy_alloc_n_source(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
@@ -639,7 +644,7 @@ inline typename dtl::disable_if_memzero_initializable<F, F>::type
 template
    <typename Allocator,
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memzero_initializable<F, F>::type
+inline typename dtl::enable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &, std::size_t n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
@@ -812,7 +817,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    copy_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
@@ -840,7 +845,7 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
@@ -867,7 +872,7 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source_dest(f, n, r);  }
 
@@ -922,7 +927,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    move_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
@@ -949,7 +954,7 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    move_backward(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iter_value<I>::type value_type;
@@ -985,7 +990,7 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 template
 <typename I    // I models InputIterator
 ,typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source_dest(f, n, r); }
 
@@ -1013,18 +1018,18 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 template
 <typename I    // I models InputIterator
 ,typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
 template<typename F>   // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE F move_forward_overlapping(F f, F l, F r)
+inline F move_forward_overlapping(F f, F l, F r)
 {
    return (f != r) ? (move)(f, l, r) : l;
 }
 
 template<typename B>   // B models BidirIterator
-BOOST_CONTAINER_FORCEINLINE B move_backward_overlapping(B f, B l, B rl)
+inline B move_backward_overlapping(B f, B l, B rl)
 {
    return (l != rl) ? (move_backward)(f, l, rl) : f;
 }
@@ -1054,7 +1059,7 @@ template
    <typename Allocator
    ,typename I   // I models InputIterator
    ,typename U>  // U models unsigned integral constant
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_trivially_destructible<I, void>::type
+inline typename dtl::enable_if_trivially_destructible<I, void>::type
    destroy_alloc_n(Allocator &, I, U)
 {}
 
@@ -1079,7 +1084,7 @@ inline typename dtl::disable_if_trivially_destructible<I, void>::type
 template
    <typename Allocator
    ,typename I >  // I models InputIterator
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_trivially_destructible<I, void>::type
+inline typename dtl::enable_if_trivially_destructible<I, void>::type
    destroy_alloc(Allocator &, I, I)
 {}
 
@@ -1458,7 +1463,7 @@ template
    , typename F // F models ForwardIterator
    , typename InsertionProxy
 >
-BOOST_CONTAINER_FORCEINLINE void expand_forward_and_insert_alloc
+inline void expand_forward_and_insert_alloc
    ( Allocator& a
    , F pos
    , F last
@@ -1780,7 +1785,7 @@ template
    , typename B // B models BidirIterator
    , typename InsertionProxy
 >
-BOOST_CONTAINER_FORCEINLINE void expand_backward_forward_and_insert_alloc_move_forward
+inline void expand_backward_forward_and_insert_alloc_move_forward
    ( B const old_start
    , std::size_t const old_size
    , B const new_start
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/destroyers.hpp b/contrib/restricted/boost/container/include/boost/container/detail/destroyers.hpp
index f00ac6d6ed..38ff874344 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/destroyers.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/destroyers.hpp
@@ -180,23 +180,23 @@ struct scoped_destructor_n
    typedef Ptr    pointer;
    typedef typename AllocTraits::value_type value_type;
 
-   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(Ptr p, Allocator& a, std::size_t n)
+   inline scoped_destructor_n(Ptr p, Allocator& a, std::size_t n)
       : m_p(p), m_n(n), m_a(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {  m_p = Ptr(); m_n = 0; }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t inc)
+   inline void increment_size(std::size_t inc)
    {  m_n += inc;   }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t inc)
+   inline void increment_size_backwards(std::size_t inc)
    {  m_n += inc;   m_p -= std::ptrdiff_t(inc);  }
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t inc)
+   inline void shrink_forward(std::size_t inc)
    {  m_n -= inc;   m_p += std::ptrdiff_t(inc);  }
 
-   BOOST_CONTAINER_FORCEINLINE void set_size(std::size_t sz)
+   inline void set_size(std::size_t sz)
    {  m_n = sz;   }
 
    ~scoped_destructor_n()
@@ -225,22 +225,22 @@ struct null_scoped_destructor_n
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef Ptr pointer;
 
-   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(Ptr, Allocator&, std::size_t)
+   inline null_scoped_destructor_n(Ptr, Allocator&, std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t)
+   inline void increment_size(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t)
+   inline void increment_size_backwards(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void set_size(std::size_t )
+   inline void set_size(std::size_t )
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t)
+   inline void shrink_forward(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {}
 };
 
@@ -254,20 +254,20 @@ struct scoped_destructor_range
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::value_type value_type;
    
-   BOOST_CONTAINER_FORCEINLINE scoped_destructor_range(pointer p, pointer e, Allocator& a)
+   inline scoped_destructor_range(pointer p, pointer e, Allocator& a)
       : m_p(p), m_e(e), m_a(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {  m_p = pointer(); m_e = pointer(); }
 
-   BOOST_CONTAINER_FORCEINLINE void set_end(pointer e)
+   inline void set_end(pointer e)
    {  m_e = e;   }
 
-   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer b)
+   inline void set_begin(pointer b)
    {  m_p = b;  }
 
-   BOOST_CONTAINER_FORCEINLINE void set_range(pointer b, pointer e)
+   inline void set_range(pointer b, pointer e)
    {  m_p = b; m_e = e;   }
 
    ~scoped_destructor_range()
@@ -293,19 +293,19 @@ struct null_scoped_destructor_range
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer pointer;
 
-   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_range(pointer, pointer, Allocator&)
+   inline null_scoped_destructor_range(pointer, pointer, Allocator&)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void set_end(pointer)
+   inline void set_end(pointer)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer)
+   inline void set_begin(pointer)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void set_range(pointer, pointer)
+   inline void set_range(pointer, pointer)
    {}
 };
 
@@ -316,24 +316,24 @@ class scoped_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   BOOST_CONTAINER_FORCEINLINE scoped_destructor(Allocator &a, value_type *pv)
+   inline scoped_destructor(Allocator &a, value_type *pv)
       : pv_(pv), a_(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE ~scoped_destructor()
+   inline ~scoped_destructor()
    {
       if(pv_){
          AllocTraits::destroy(a_, pv_);
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {  pv_ = 0; }
 
 
-   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
+   inline void set(value_type *ptr) { pv_ = ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
+   inline value_type *get() const { return pv_; }
 
    private:
    value_type *pv_;
@@ -346,18 +346,18 @@ class null_scoped_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor(Allocator &, value_type *)
+   inline null_scoped_destructor(Allocator &, value_type *)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE ~null_scoped_destructor()
+   inline ~null_scoped_destructor()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void set(value_type *) { }
+   inline void set(value_type *) { }
 
-   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return 0; }
+   inline value_type *get() const { return 0; }
 };
 
 
@@ -368,11 +368,11 @@ class value_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef Value value_type;
-   BOOST_CONTAINER_FORCEINLINE value_destructor(Allocator &a, value_type &rv)
+   inline value_destructor(Allocator &a, value_type &rv)
       : rv_(rv), a_(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE ~value_destructor()
+   inline ~value_destructor()
    {
       AllocTraits::destroy(a_, &rv_);
    }
@@ -396,18 +396,18 @@ class allocator_node_destroyer
    Allocator & a_;
 
    private:
-   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_1)
+   inline void priv_deallocate(const pointer &p, version_1)
    {  AllocTraits::deallocate(a_,p, 1); }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_2)
+   inline void priv_deallocate(const pointer &p, version_2)
    {  a_.deallocate_one(p); }
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit allocator_node_destroyer(Allocator &a)
+   inline explicit allocator_node_destroyer(Allocator &a)
       : a_(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void operator()(const pointer &p)
+   inline void operator()(const pointer &p)
    {
       boost::movelib::to_raw_pointer(p)->destructor(a_);
       this->priv_deallocate(p, alloc_version());
@@ -420,24 +420,24 @@ class scoped_node_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   BOOST_CONTAINER_FORCEINLINE scoped_node_destructor(Allocator &a, value_type *pv)
+   inline scoped_node_destructor(Allocator &a, value_type *pv)
       : pv_(pv), a_(a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE ~scoped_node_destructor()
+   inline ~scoped_node_destructor()
    {
       if(pv_){
          pv_->destructor(a_);
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void release()
+   inline void release()
    {  pv_ = 0; }
 
 
-   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
+   inline void set(value_type *ptr) { pv_ = ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
+   inline value_type *get() const { return pv_; }
 
    private:
    value_type *pv_;
@@ -457,11 +457,11 @@ class allocator_node_destroyer_and_chain_builder
    multiallocation_chain &c_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE allocator_node_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
+   inline allocator_node_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
       :  a_(a), c_(c)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void operator()(const typename Allocator::pointer &p)
+   inline void operator()(const typename Allocator::pointer &p)
    {
       boost::movelib::to_raw_pointer(p)->destructor(a_);
       c_.push_back(p);
@@ -480,14 +480,14 @@ class allocator_multialloc_chain_node_deallocator
    multiallocation_chain c_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE allocator_multialloc_chain_node_deallocator(Allocator &a)
+   inline allocator_multialloc_chain_node_deallocator(Allocator &a)
       :  a_(a), c_()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE chain_builder get_chain_builder()
+   inline chain_builder get_chain_builder()
    {  return chain_builder(a_, c_);  }
 
-   BOOST_CONTAINER_FORCEINLINE ~allocator_multialloc_chain_node_deallocator()
+   inline ~allocator_multialloc_chain_node_deallocator()
    {
       a_.deallocate_individual(c_);
    }
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/dispatch_uses_allocator.hpp b/contrib/restricted/boost/container/include/boost/container/detail/dispatch_uses_allocator.hpp
index 42fd4f4fd7..5bb7687d5a 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/dispatch_uses_allocator.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/dispatch_uses_allocator.hpp
@@ -110,7 +110,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
+inline typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , dtl::not_< uses_allocator<T, typename remove_cvref<ArgAlloc>::type > >
@@ -127,7 +127,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
+inline typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>
@@ -146,7 +146,7 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
+inline typename dtl::enable_if_and
    < void
    , dtl::is_not_pair<T>
    , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>
@@ -162,7 +162,7 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template <typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , dtl::not_<uses_allocator<T, typename remove_cvref<ArgAlloc>::type> >\
@@ -179,7 +179,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>\
@@ -197,7 +197,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
       , dtl::is_not_pair<T>\
       , uses_allocator<T, typename remove_cvref<ArgAlloc>::type>\
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/iterators.hpp b/contrib/restricted/boost/container/include/boost/container/detail/iterators.hpp
index c503916a96..57ffb0ced4 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/iterators.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/iterators.hpp
@@ -27,7 +27,6 @@
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/value_init.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/intrusive/detail/reverse_iterator.hpp>
 
@@ -49,125 +48,125 @@ class constant_iterator
    typedef  constant_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit constant_iterator(const T &ref, std::size_t range_size)
+   inline explicit constant_iterator(const T &ref, std::size_t range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE constant_iterator()
+   inline constant_iterator()
       :  m_ptr(0), m_num(0){}
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator++()
+   inline constant_iterator& operator++()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator++(int)
+   inline constant_iterator operator++(int)
    {
       constant_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator--()
+   inline constant_iterator& operator--()
    { decrement();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator--(int)
+   inline constant_iterator operator--(int)
    {
       constant_iterator result (*this);
       decrement();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
    { return i.less(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
    { return i2 < i; }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i > i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
+   inline friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const constant_iterator& i, const constant_iterator& i2)
+   inline friend std::ptrdiff_t operator- (const constant_iterator& i, const constant_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic signed
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(std::ptrdiff_t off)
+   inline constant_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(std::ptrdiff_t off) const
+   inline constant_iterator operator+(std::ptrdiff_t off) const
    {
       constant_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(std::ptrdiff_t off, const constant_iterator& right)
+   inline friend constant_iterator operator+(std::ptrdiff_t off, const constant_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(std::ptrdiff_t off)
+   inline constant_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(std::ptrdiff_t off) const
+   inline constant_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
-   BOOST_CONTAINER_FORCEINLINE const T& operator[] (std::ptrdiff_t ) const
+   inline const T& operator[] (std::ptrdiff_t ) const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE const T& operator*() const
+   inline const T& operator*() const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE const T* operator->() const
+   inline const T* operator->() const
    { return &(dereference()); }
 
    //Arithmetic unsigned
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(std::size_t off)
+   inline constant_iterator& operator+=(std::size_t off)
    {  return *this += std::ptrdiff_t(off);  }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(std::size_t off) const
+   inline constant_iterator operator+(std::size_t off) const
    {  return *this + std::ptrdiff_t(off);  }
 
-   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(std::size_t off, const constant_iterator& right)
+   inline friend constant_iterator operator+(std::size_t off, const constant_iterator& right)
    {  return std::ptrdiff_t(off) + right;  }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(std::size_t off)
+   inline constant_iterator& operator-=(std::size_t off)
    {  return *this -= std::ptrdiff_t(off);  }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(std::size_t off) const
+   inline constant_iterator operator-(std::size_t off) const
    {  return *this - std::ptrdiff_t(off);  }
 
-   BOOST_CONTAINER_FORCEINLINE const T& operator[] (std::size_t off) const
+   inline const T& operator[] (std::size_t off) const
    { return (*this)[std::ptrdiff_t(off)]; }
 
    private:
    const T *   m_ptr;
    std::size_t m_num;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { --m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { ++m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
+   inline bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
+   inline bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
+   inline const T & dereference() const
    { return *m_ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
+   inline void advance(std::ptrdiff_t n)
    {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
+   inline std::ptrdiff_t distance_to(const this_type &other)const
    {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
@@ -179,72 +178,72 @@ class value_init_construct_iterator
    typedef  value_init_construct_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit value_init_construct_iterator(std::size_t range_size)
+   inline explicit value_init_construct_iterator(std::size_t range_size)
       :  m_num(range_size){}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator()
+   inline value_init_construct_iterator()
       :  m_num(0){}
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator++()
+   inline value_init_construct_iterator& operator++()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator++(int)
+   inline value_init_construct_iterator operator++(int)
    {
       value_init_construct_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator--()
+   inline value_init_construct_iterator& operator--()
    { decrement();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator--(int)
+   inline value_init_construct_iterator operator--(int)
    {
       value_init_construct_iterator result (*this);
       decrement();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i.less(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i2 < i; }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i > i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   inline friend std::ptrdiff_t operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator+=(std::ptrdiff_t off)
+   inline value_init_construct_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator+(std::ptrdiff_t off) const
+   inline value_init_construct_iterator operator+(std::ptrdiff_t off) const
    {
       value_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend value_init_construct_iterator operator+(std::ptrdiff_t off, const value_init_construct_iterator& right)
+   inline friend value_init_construct_iterator operator+(std::ptrdiff_t off, const value_init_construct_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator-=(std::ptrdiff_t off)
+   inline value_init_construct_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator-(std::ptrdiff_t off) const
+   inline value_init_construct_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -257,28 +256,28 @@ class value_init_construct_iterator
    private:
    std::size_t  m_num;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { --m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { ++m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
+   inline bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
+   inline bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
+   inline const T & dereference() const
    {
       static T dummy;
       return dummy;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
+   inline void advance(std::ptrdiff_t n)
    {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
+   inline std::ptrdiff_t distance_to(const this_type &other)const
    {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
@@ -290,72 +289,72 @@ class default_init_construct_iterator
    typedef  default_init_construct_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit default_init_construct_iterator(std::size_t range_size)
+   inline explicit default_init_construct_iterator(std::size_t range_size)
       :  m_num(range_size){}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator()
+   inline default_init_construct_iterator()
       :  m_num(0){}
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator++()
+   inline default_init_construct_iterator& operator++()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator++(int)
+   inline default_init_construct_iterator operator++(int)
    {
       default_init_construct_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator--()
+   inline default_init_construct_iterator& operator--()
    { decrement();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator--(int)
+   inline default_init_construct_iterator operator--(int)
    {
       default_init_construct_iterator result (*this);
       decrement();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i == i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i.less(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i2 < i; }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i > i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   inline friend std::ptrdiff_t operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator+=(std::ptrdiff_t off)
+   inline default_init_construct_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator+(std::ptrdiff_t off) const
+   inline default_init_construct_iterator operator+(std::ptrdiff_t off) const
    {
       default_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend default_init_construct_iterator operator+(std::ptrdiff_t off, const default_init_construct_iterator& right)
+   inline friend default_init_construct_iterator operator+(std::ptrdiff_t off, const default_init_construct_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator-=(std::ptrdiff_t off)
+   inline default_init_construct_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator-(std::ptrdiff_t off) const
+   inline default_init_construct_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -368,28 +367,28 @@ class default_init_construct_iterator
    private:
    std::size_t  m_num;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { --m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { ++m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
+   inline bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
+   inline bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
+   inline const T & dereference() const
    {
       static T dummy;
       return dummy;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
+   inline void advance(std::ptrdiff_t n)
    {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other) const
+   inline std::ptrdiff_t distance_to(const this_type &other) const
    {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
@@ -401,106 +400,106 @@ class repeat_iterator
 {
    typedef repeat_iterator<T> this_type;
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit repeat_iterator(T &ref, std::size_t range_size)
+   inline explicit repeat_iterator(T &ref, std::size_t range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE repeat_iterator()
+   inline repeat_iterator()
       :  m_ptr(0), m_num(0){}
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator++()
+   inline this_type& operator++()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator++(int)
+   inline this_type operator++(int)
    {
       this_type result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator--()
+   inline this_type& operator--()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator--(int)
+   inline this_type operator--(int)
    {
       this_type result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const this_type& i, const this_type& i2)
+   inline friend bool operator== (const this_type& i, const this_type& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const this_type& i, const this_type& i2)
+   inline friend bool operator!= (const this_type& i, const this_type& i2)
    { return !(i == i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const this_type& i, const this_type& i2)
+   inline friend bool operator< (const this_type& i, const this_type& i2)
    { return i.less(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const this_type& i, const this_type& i2)
+   inline friend bool operator> (const this_type& i, const this_type& i2)
    { return i2 < i; }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const this_type& i, const this_type& i2)
+   inline friend bool operator<= (const this_type& i, const this_type& i2)
    { return !(i > i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const this_type& i, const this_type& i2)
+   inline friend bool operator>= (const this_type& i, const this_type& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
+   inline friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE this_type& operator+=(std::ptrdiff_t off)
+   inline this_type& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator+(std::ptrdiff_t off) const
+   inline this_type operator+(std::ptrdiff_t off) const
    {
       this_type other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend this_type operator+(std::ptrdiff_t off, const this_type& right)
+   inline friend this_type operator+(std::ptrdiff_t off, const this_type& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator-=(std::ptrdiff_t off)
+   inline this_type& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator-(std::ptrdiff_t off) const
+   inline this_type operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
-   BOOST_CONTAINER_FORCEINLINE T& operator*() const
+   inline T& operator*() const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE T& operator[] (std::ptrdiff_t ) const
+   inline T& operator[] (std::ptrdiff_t ) const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE T *operator->() const
+   inline T *operator->() const
    { return &(dereference()); }
 
    private:
    T *         m_ptr;
    std::size_t m_num;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { --m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { ++m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
+   inline bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
+   inline bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE T & dereference() const
+   inline T & dereference() const
    { return *m_ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
+   inline void advance(std::ptrdiff_t n)
    {  m_num = std::size_t(std::ptrdiff_t(m_num - n)); }
 
-   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
+   inline std::ptrdiff_t distance_to(const this_type &other)const
    {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
@@ -513,71 +512,71 @@ class emplace_iterator
 
    public:
    typedef std::ptrdiff_t difference_type;
-   BOOST_CONTAINER_FORCEINLINE explicit emplace_iterator(EmplaceFunctor&e)
+   inline explicit emplace_iterator(EmplaceFunctor&e)
       :  m_num(1), m_pe(&e){}
 
-   BOOST_CONTAINER_FORCEINLINE emplace_iterator()
+   inline emplace_iterator()
       :  m_num(0), m_pe(0){}
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator++()
+   inline this_type& operator++()
    { increment();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator++(int)
+   inline this_type operator++(int)
    {
       this_type result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator--()
+   inline this_type& operator--()
    { decrement();   return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator--(int)
+   inline this_type operator--(int)
    {
       this_type result (*this);
       decrement();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const this_type& i, const this_type& i2)
+   inline friend bool operator== (const this_type& i, const this_type& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const this_type& i, const this_type& i2)
+   inline friend bool operator!= (const this_type& i, const this_type& i2)
    { return !(i == i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator< (const this_type& i, const this_type& i2)
+   inline friend bool operator< (const this_type& i, const this_type& i2)
    { return i.less(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator> (const this_type& i, const this_type& i2)
+   inline friend bool operator> (const this_type& i, const this_type& i2)
    { return i2 < i; }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator<= (const this_type& i, const this_type& i2)
+   inline friend bool operator<= (const this_type& i, const this_type& i2)
    { return !(i > i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const this_type& i, const this_type& i2)
+   inline friend bool operator>= (const this_type& i, const this_type& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend difference_type operator- (const this_type& i, const this_type& i2)
+   inline friend difference_type operator- (const this_type& i, const this_type& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE this_type& operator+=(difference_type off)
+   inline this_type& operator+=(difference_type off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator+(difference_type off) const
+   inline this_type operator+(difference_type off) const
    {
       this_type other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend this_type operator+(difference_type off, const this_type& right)
+   inline friend this_type operator+(difference_type off, const this_type& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator-=(difference_type off)
+   inline this_type& operator-=(difference_type off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator-(difference_type off) const
+   inline this_type operator-(difference_type off) const
    {  return *this + (-off);  }
 
    private:
@@ -590,39 +589,39 @@ class emplace_iterator
 
    public:
    template<class Allocator>
-   BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T* ptr)
+   inline void construct_in_place(Allocator &a, T* ptr)
    {  (*m_pe)(a, ptr);  }
 
    template<class DestIt>
-   BOOST_CONTAINER_FORCEINLINE void assign_in_place(DestIt dest)
+   inline void assign_in_place(DestIt dest)
    {  (*m_pe)(dest);  }
 
    private:
    std::size_t m_num;
    EmplaceFunctor *            m_pe;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { --m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { ++m_num; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const this_type &other) const
+   inline bool equal(const this_type &other) const
    {  return m_num == other.m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const this_type &other) const
+   inline bool less(const this_type &other) const
    {  return other.m_num < m_num;   }
 
-   BOOST_CONTAINER_FORCEINLINE const T & dereference() const
+   inline const T & dereference() const
    {
       static T dummy;
       return dummy;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(difference_type n)
+   inline void advance(difference_type n)
    {  m_num -= n; }
 
-   BOOST_CONTAINER_FORCEINLINE difference_type distance_to(const this_type &other)const
+   inline difference_type distance_to(const this_type &other)const
    {  return difference_type(m_num - other.m_num);   }
 };
 
@@ -633,28 +632,28 @@ struct emplace_functor
 {
    typedef typename dtl::build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
-   BOOST_CONTAINER_FORCEINLINE emplace_functor(BOOST_FWD_REF(Args)... args)
+   inline emplace_functor(BOOST_FWD_REF(Args)... args)
       : args_(args...)
    {}
 
    template<class Allocator, class T>
-   BOOST_CONTAINER_FORCEINLINE void operator()(Allocator &a, T *ptr)
+   inline void operator()(Allocator &a, T *ptr)
    {  emplace_functor::inplace_impl(a, ptr, index_tuple_t());  }
 
    template<class DestIt>
-   BOOST_CONTAINER_FORCEINLINE void operator()(DestIt dest)
+   inline void operator()(DestIt dest)
    {  emplace_functor::inplace_impl(dest, index_tuple_t());  }
 
    private:
    template<class Allocator, class T, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple<IdxPack...>&)
+   inline void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple<IdxPack...>&)
    {
       allocator_traits<Allocator>::construct
          (a, ptr, ::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
    }
 
    template<class DestIt, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const dtl::index_tuple<IdxPack...>&)
+   inline void inplace_impl(DestIt dest, const dtl::index_tuple<IdxPack...>&)
    {
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;
       value_type && tmp= value_type(::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
@@ -680,15 +679,15 @@ struct emplace_functor_type;
 BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
 struct emplace_functor##N\
 {\
-   BOOST_CONTAINER_FORCEINLINE explicit emplace_functor##N( BOOST_MOVE_UREF##N )\
+   inline explicit emplace_functor##N( BOOST_MOVE_UREF##N )\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N{}\
    \
    template<class Allocator, class T>\
-   BOOST_CONTAINER_FORCEINLINE void operator()(Allocator &a, T *ptr)\
+   inline void operator()(Allocator &a, T *ptr)\
    {  allocator_traits<Allocator>::construct(a, ptr BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);  }\
    \
    template<class DestIt>\
-   BOOST_CONTAINER_FORCEINLINE void operator()(DestIt dest)\
+   inline void operator()(DestIt dest)\
    {\
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;\
       BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), dtl::value_init<value_type> tmp) ;\
@@ -836,62 +835,62 @@ class iterator_from_iiterator
    typedef typename types_t::iterator_category   iterator_category;
    typedef typename types_t::value_type          value_type;
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator()
+   inline iterator_from_iiterator()
       : m_iit()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit iterator_from_iiterator(IIterator iit) BOOST_NOEXCEPT_OR_NOTHROW
+   inline explicit iterator_from_iiterator(IIterator iit) BOOST_NOEXCEPT_OR_NOTHROW
       : m_iit(iit)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_iit(other.get())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator(const nonconst_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator(const nonconst_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_iit(other.get())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator=(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator& operator=(const iterator_from_iiterator& other) BOOST_NOEXCEPT_OR_NOTHROW
    {  m_iit = other.get(); return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
    {  ++this->m_iit;   return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
    {
       iterator_from_iiterator result (*this);
       ++this->m_iit;
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
    {
       //If the iterator_from_iiterator is not a bidirectional iterator, operator-- should not exist
-      BOOST_STATIC_ASSERT((is_bidirectional_iterator<iterator_from_iiterator>::value));
+      BOOST_CONTAINER_STATIC_ASSERT((is_bidirectional_iterator<iterator_from_iiterator>::value));
       --this->m_iit;   return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline iterator_from_iiterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
    {
       iterator_from_iiterator result (*this);
       --this->m_iit;
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator== (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_iit == r.m_iit;   }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator!= (const iterator_from_iiterator& l, const iterator_from_iiterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_iit != r.m_iit;   }
 
-   BOOST_CONTAINER_FORCEINLINE reference operator*()  const BOOST_NOEXCEPT_OR_NOTHROW
+   inline reference operator*()  const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_iit->get_data();  }
 
-   BOOST_CONTAINER_FORCEINLINE pointer   operator->() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline pointer   operator->() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*());  }
 
-   BOOST_CONTAINER_FORCEINLINE const IIterator &get() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const IIterator &get() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_iit;   }
 
    private:
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/next_capacity.hpp b/contrib/restricted/boost/container/include/boost/container/detail/next_capacity.hpp
index 9777b1473b..76bf0a0e7d 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/next_capacity.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/next_capacity.hpp
@@ -26,8 +26,6 @@
 // container/detail
 #include <boost/container/detail/min_max.hpp>
 
-#include <boost/static_assert.hpp>
-
 namespace boost {
 namespace container {
 namespace dtl {
@@ -35,10 +33,10 @@ namespace dtl {
 template<unsigned Minimum, unsigned Numerator, unsigned Denominator>
 struct grow_factor_ratio
 {
-   BOOST_STATIC_ASSERT(Numerator > Denominator);
-   BOOST_STATIC_ASSERT(Numerator   < 100);
-   BOOST_STATIC_ASSERT(Denominator < 100);
-   BOOST_STATIC_ASSERT(Denominator == 1 || (0 != Numerator % Denominator));
+   BOOST_CONTAINER_STATIC_ASSERT(Numerator > Denominator);
+   BOOST_CONTAINER_STATIC_ASSERT(Numerator   < 100);
+   BOOST_CONTAINER_STATIC_ASSERT(Denominator < 100);
+   BOOST_CONTAINER_STATIC_ASSERT(Denominator == 1 || (0 != Numerator % Denominator));
 
    template<class SizeType>
    SizeType operator()(const SizeType cur_cap, const SizeType add_min_cap, const SizeType max_cap) const
@@ -80,11 +78,11 @@ struct growth_factor_100
 {};
 
 template<class SizeType>
-BOOST_CONTAINER_FORCEINLINE void clamp_by_stored_size_type(SizeType &, SizeType)
+inline void clamp_by_stored_size_type(SizeType &, SizeType)
 {}
 
 template<class SizeType, class SomeStoredSizeType>
-BOOST_CONTAINER_FORCEINLINE void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
+inline void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
 {
    if (s >= SomeStoredSizeType(-1) ) 
       s = SomeStoredSizeType(-1);
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/node_alloc_holder.hpp b/contrib/restricted/boost/container/include/boost/container/detail/node_alloc_holder.hpp
index 8db384e4f6..1ebf21ad84 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/node_alloc_holder.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/node_alloc_holder.hpp
@@ -118,16 +118,16 @@ struct base_node
       ::boost::container::construct_in_place(a, &this->get_real_data(), it);
    }
 
-   BOOST_CONTAINER_FORCEINLINE T &get_data()
+   inline T &get_data()
    {  return *move_detail::force_ptr<T*>(this->m_storage.data);   }
 
-   BOOST_CONTAINER_FORCEINLINE const T &get_data() const
+   inline const T &get_data() const
    {  return *move_detail::force_ptr<const T*>(this->m_storage.data);  }
 
-   BOOST_CONTAINER_FORCEINLINE internal_type &get_real_data()
+   inline internal_type &get_real_data()
    {  return *move_detail::force_ptr<internal_type*>(this->m_storage.data);   }
 
-   BOOST_CONTAINER_FORCEINLINE const internal_type &get_real_data() const
+   inline const internal_type &get_real_data() const
    {  return *move_detail::force_ptr<const internal_type*>(this->m_storage.data);  }
 
    #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
@@ -136,7 +136,7 @@ struct base_node
    #  endif
 
    template<class Alloc>
-   BOOST_CONTAINER_FORCEINLINE void destructor(Alloc &a) BOOST_NOEXCEPT
+   inline void destructor(Alloc &a) BOOST_NOEXCEPT
    {
       allocator_traits<Alloc>::destroy
          (a, &this->get_real_data());
@@ -144,7 +144,7 @@ struct base_node
    }
 
    template<class Pair>
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       do_assign(const Pair &p)
    {
@@ -154,13 +154,13 @@ struct base_node
    }
 
    template<class V>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::disable_if< dtl::is_pair<V>, void >::type
       do_assign(const V &v)
    {  this->get_real_data() = v; }
 
    template<class Pair>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
       do_move_assign(Pair &p)
    {
@@ -170,7 +170,7 @@ struct base_node
    }
 
    template<class V>
-   BOOST_CONTAINER_FORCEINLINE 
+   inline 
    typename dtl::disable_if< dtl::is_pair<V>, void >::type
       do_move_assign(V &v)
    {  this->get_real_data() = ::boost::move(v); }
@@ -178,7 +178,7 @@ struct base_node
    private:
    base_node();
 
-   BOOST_CONTAINER_FORCEINLINE ~base_node()
+   inline ~base_node()
    { }
 };
 
@@ -256,7 +256,7 @@ struct node_alloc_holder
    public:
 
    //Constructors for sequence containers
-   BOOST_CONTAINER_FORCEINLINE node_alloc_holder()
+   inline node_alloc_holder()
    {}
 
    explicit node_alloc_holder(const intrusive_bucket_traits& bt)
@@ -339,30 +339,30 @@ struct node_alloc_holder
                , typename ICont::key_equal(eql))
    {  this->icont().swap(BOOST_MOVE_TO_LV(x).icont());   }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_assign_alloc(const node_alloc_holder &x)
+   inline void copy_assign_alloc(const node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
       dtl::assign_alloc( static_cast<NodeAlloc &>(*this)
                        , static_cast<const NodeAlloc &>(x), flag);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void move_assign_alloc( node_alloc_holder &x)
+   inline void move_assign_alloc( node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
       dtl::move_alloc( static_cast<NodeAlloc &>(*this)
                      , static_cast<NodeAlloc &>(x), flag);
    }
 
-   BOOST_CONTAINER_FORCEINLINE ~node_alloc_holder()
+   inline ~node_alloc_holder()
    {  this->clear(alloc_version()); }
 
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const
+   inline size_type max_size() const
    {  return allocator_traits_type::max_size(this->node_alloc());  }
 
-   BOOST_CONTAINER_FORCEINLINE NodePtr allocate_one()
+   inline NodePtr allocate_one()
    {  return AllocVersionTraits::allocate_one(this->node_alloc());   }
 
-   BOOST_CONTAINER_FORCEINLINE void deallocate_one(const NodePtr &p)
+   inline void deallocate_one(const NodePtr &p)
    {  AllocVersionTraits::deallocate_one(this->node_alloc(), p);  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -497,7 +497,7 @@ struct node_alloc_holder
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void clear(version_1)
+   inline void clear(version_1)
    {  this->icont().clear_and_dispose(Destroyer(this->node_alloc()));   }
 
    void clear(version_2)
@@ -505,7 +505,7 @@ struct node_alloc_holder
       typename NodeAlloc::multiallocation_chain chain;
       allocator_node_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
       this->icont().clear_and_dispose(builder);
-      //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
+      //BOOST_CONTAINER_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
       if(!chain.empty())
          this->node_alloc().deallocate_individual(chain);
    }
@@ -524,11 +524,11 @@ struct node_alloc_holder
    }
 
    template<class Key>
-   BOOST_CONTAINER_FORCEINLINE size_type erase_key(const Key& k, version_1)
+   inline size_type erase_key(const Key& k, version_1)
    {  return this->icont().erase_and_dispose(k, Destroyer(this->node_alloc())); }
 
    template<class Key>
-   BOOST_CONTAINER_FORCEINLINE size_type erase_key(const Key& k, version_2)
+   inline size_type erase_key(const Key& k, version_2)
    {
       allocator_multialloc_chain_node_deallocator<NodeAlloc> chain_holder(this->node_alloc());
       return this->icont().erase_and_dispose(k, chain_holder.get_chain_builder());
@@ -537,11 +537,11 @@ struct node_alloc_holder
    protected:
    struct cloner
    {
-      BOOST_CONTAINER_FORCEINLINE explicit cloner(node_alloc_holder &holder)
+      inline explicit cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE NodePtr operator()(const Node &other) const
+      inline NodePtr operator()(const Node &other) const
       {  return m_holder.create_node(other.get_real_data());  }
 
       node_alloc_holder &m_holder;
@@ -549,11 +549,11 @@ struct node_alloc_holder
 
    struct move_cloner
    {
-      BOOST_CONTAINER_FORCEINLINE move_cloner(node_alloc_holder &holder)
+      inline move_cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      BOOST_CONTAINER_FORCEINLINE NodePtr operator()(Node &other)
+      inline NodePtr operator()(Node &other)
       {  //Use get_real_data() instead of get_real_data to allow moving const key in [multi]map
          return m_holder.create_node(::boost::move(other.get_real_data()));
       }
@@ -561,20 +561,20 @@ struct node_alloc_holder
       node_alloc_holder &m_holder;
    };
 
-   BOOST_CONTAINER_FORCEINLINE ICont &non_const_icont() const
+   inline ICont &non_const_icont() const
    {  return const_cast<ICont&>(this->m_icont);   }
 
-   BOOST_CONTAINER_FORCEINLINE NodeAlloc &node_alloc()
+   inline NodeAlloc &node_alloc()
    {  return static_cast<NodeAlloc &>(*this);   }
 
-   BOOST_CONTAINER_FORCEINLINE const NodeAlloc &node_alloc() const
+   inline const NodeAlloc &node_alloc() const
    {  return static_cast<const NodeAlloc &>(*this);   }
 
    public:
-   BOOST_CONTAINER_FORCEINLINE ICont &icont()
+   inline ICont &icont()
    {  return this->m_icont;   }
 
-   BOOST_CONTAINER_FORCEINLINE const ICont &icont() const
+   inline const ICont &icont() const
    {  return this->m_icont;   }
 
    protected:
@@ -587,10 +587,10 @@ struct key_of_node : KeyOfValue
 {
    typedef typename KeyOfValue::type type;
 
-   BOOST_CONTAINER_FORCEINLINE key_of_node()
+   inline key_of_node()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE const type& operator()(const Node& x) const
+   inline const type& operator()(const Node& x) const
    {  return this->KeyOfValue::operator()(x.get_data());  }
 };
 
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/pair.hpp b/contrib/restricted/boost/container/include/boost/container/detail/pair.hpp
index 56b2fb8311..58e560817a 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/pair.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/pair.hpp
@@ -25,7 +25,6 @@
 #include <boost/container/container_fwd.hpp>
 #include <boost/container/detail/workaround.hpp>
 
-#include <boost/static_assert.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
@@ -166,35 +165,35 @@ struct pair
    pair()
       : first(), second()
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair copy assignment
    pair(const pair& x)
       : first(x.first), second(x.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair move constructor
    pair(BOOST_RV_REF(pair) p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(const pair<D, S> &p)
       : first(p.first), second(p.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //pair from two values
@@ -202,7 +201,7 @@ struct pair
       : first(t1)
       , second(t2)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template<class U, class V>
@@ -210,34 +209,34 @@ struct pair
       : first(::boost::forward<U>(u))
       , second(::boost::forward<V>(v))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    //And now compatibility with std::pair
    pair(const std::pair<T1, T2>& x)
       : first(x.first), second(x.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(const std::pair<D, S>& p)
       : first(p.first), second(p.second)
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -245,7 +244,7 @@ struct pair
    pair(try_emplace_t, BOOST_FWD_REF(KeyType) k, Args && ...args)
       : first(boost::forward<KeyType>(k)), second(::boost::forward<Args>(args)...)\
    {
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
    #else
 
@@ -255,7 +254,7 @@ struct pair
    pair( try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N )\
       : first(boost::forward<KeyType>(k)), second(BOOST_MOVE_FWD##N)\
    {\
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_PAIR_TRY_EMPLACE_CONSTRUCT_CODE)
@@ -277,7 +276,7 @@ struct pair
        )\
       : first(BOOST_MOVE_TMPL_GET##N), second(BOOST_MOVE_TMPL_GETQ##M)\
    { (void)p; (void)q;\
-      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
    }\
    //
    BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE)
@@ -299,7 +298,7 @@ struct pair
       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())
       {
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
       }
    #  else
       //piecewise construction from variadic tuple (suboptimal, without delegating constructors)
@@ -319,7 +318,7 @@ struct pair
          : first  (build_from_args<first_type> (::boost::move(t1)))
          , second (build_from_args<second_type>(::boost::move(t2)))
       {
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
       }
    #  endif   //BOOST_NO_CXX11_VARIADIC_TEMPLATES
    #elif defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
@@ -332,7 +331,7 @@ struct pair
           , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
       { (void)p; (void)q;\
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
       }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE)
@@ -353,7 +352,7 @@ struct pair
           , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),M),::std::_Nil) > q)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
       { (void)p; (void)q;\
-         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+         BOOST_CONTAINER_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
       }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_MAX_IT, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_CODE)
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/transform_iterator.hpp b/contrib/restricted/boost/container/include/boost/container/detail/transform_iterator.hpp
index 5c7bbf2dd0..35b64b85fe 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/transform_iterator.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/transform_iterator.hpp
@@ -33,13 +33,13 @@ namespace container {
 template <class PseudoReference>
 struct operator_arrow_proxy
 {
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(const PseudoReference &px)
+   inline operator_arrow_proxy(const PseudoReference &px)
       :  m_value(px)
    {}
 
    typedef PseudoReference element_type;
 
-   BOOST_CONTAINER_FORCEINLINE PseudoReference* operator->() const { return &m_value; }
+   inline PseudoReference* operator->() const { return &m_value; }
 
    mutable PseudoReference m_value;
 };
@@ -47,13 +47,13 @@ struct operator_arrow_proxy
 template <class T>
 struct operator_arrow_proxy<T&>
 {
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(T &px)
+   inline operator_arrow_proxy(T &px)
       :  m_value(px)
    {}
 
    typedef T element_type;
 
-   BOOST_CONTAINER_FORCEINLINE T* operator->() const { return const_cast<T*>(&m_value); }
+   inline T* operator->() const { return const_cast<T*>(&m_value); }
 
    T &m_value;
 };
@@ -69,29 +69,29 @@ class transform_iterator
       , typename UnaryFunction::result_type>
 {
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
+   inline explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
       :  UnaryFunction(f), m_it(it)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator()
+   inline explicit transform_iterator()
       :  UnaryFunction(), m_it()
    {}
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator++()
+   inline transform_iterator& operator++()
    { increment();   return *this;   }
 
-      BOOST_CONTAINER_FORCEINLINE transform_iterator operator++(int)
+      inline transform_iterator operator++(int)
    {
       transform_iterator result (*this);
       increment();
       return result;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
    { return i.equal(i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   inline friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
 /*
@@ -104,69 +104,69 @@ class transform_iterator
    friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i < i2); }
 */
-   BOOST_CONTAINER_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   inline friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator+=(typename Iterator::difference_type off)
+   inline transform_iterator& operator+=(typename Iterator::difference_type off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const
+   inline transform_iterator operator+(typename Iterator::difference_type off) const
    {
       transform_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   inline friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off)
+   inline transform_iterator& operator-=(typename Iterator::difference_type off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const
+   inline transform_iterator operator-(typename Iterator::difference_type off) const
    {  return *this + (-off);  }
 
-   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type operator*() const
+   inline typename UnaryFunction::result_type operator*() const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type>
+   inline operator_arrow_proxy<typename UnaryFunction::result_type>
       operator->() const
    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 
-   BOOST_CONTAINER_FORCEINLINE Iterator & base()
+   inline Iterator & base()
    {  return m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE const Iterator & base() const
+   inline const Iterator & base() const
    {  return m_it;   }
 
    private:
    Iterator m_it;
 
-   BOOST_CONTAINER_FORCEINLINE void increment()
+   inline void increment()
    { ++m_it; }
 
-   BOOST_CONTAINER_FORCEINLINE void decrement()
+   inline void decrement()
    { --m_it; }
 
-   BOOST_CONTAINER_FORCEINLINE bool equal(const transform_iterator &other) const
+   inline bool equal(const transform_iterator &other) const
    {  return m_it == other.m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE bool less(const transform_iterator &other) const
+   inline bool less(const transform_iterator &other) const
    {  return other.m_it < m_it;   }
 
-   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type dereference() const
+   inline typename UnaryFunction::result_type dereference() const
    { return UnaryFunction::operator()(*m_it); }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(typename Iterator::difference_type n)
+   inline void advance(typename Iterator::difference_type n)
    {  boost::container::iterator_advance(m_it, n); }
 
-   BOOST_CONTAINER_FORCEINLINE typename Iterator::difference_type distance_to(const transform_iterator &other)const
+   inline typename Iterator::difference_type distance_to(const transform_iterator &other)const
    {  return boost::container::iterator_distance(other.m_it, m_it); }
 };
 
 template <class Iterator, class UnaryFunc>
-BOOST_CONTAINER_FORCEINLINE transform_iterator<Iterator, UnaryFunc>
+inline transform_iterator<Iterator, UnaryFunc>
 make_transform_iterator(Iterator it, UnaryFunc fun)
 {
    return transform_iterator<Iterator, UnaryFunc>(it, fun);
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/tree.hpp b/contrib/restricted/boost/container/include/boost/container/detail/tree.hpp
index 843ad3cb78..f4a27b200e 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/tree.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/tree.hpp
@@ -131,11 +131,11 @@ class insert_equal_end_hint_functor
    Icont &icont_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE insert_equal_end_hint_functor(Icont &icont)
+   inline insert_equal_end_hint_functor(Icont &icont)
       :  icont_(icont)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void operator()(Node &n)
+   inline void operator()(Node &n)
    {  this->icont_.insert_equal(this->icont_.cend(), n); }
 };
 
@@ -145,11 +145,11 @@ class push_back_functor
    Icont &icont_;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE push_back_functor(Icont &icont)
+   inline push_back_functor(Icont &icont)
       :  icont_(icont)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void operator()(Node &n)
+   inline void operator()(Node &n)
    {  this->icont_.push_back(n); }
 };
 
@@ -267,14 +267,14 @@ template< boost::container::tree_type_enum tree_type_value
 struct intrusive_tree_proxy
 {
    template<class Icont>
-   BOOST_CONTAINER_FORCEINLINE static void rebalance(Icont &)   {}
+   inline static void rebalance(Icont &)   {}
 };
 
 template<boost::container::tree_type_enum tree_type_value>
 struct intrusive_tree_proxy<tree_type_value, true>
 {
    template<class Icont>
-   BOOST_CONTAINER_FORCEINLINE static void rebalance(Icont &c)
+   inline static void rebalance(Icont &c)
    {  c.rebalance(); }
 };
 
@@ -298,10 +298,10 @@ class RecyclingCloner
       :  m_holder(holder), m_icont(itree)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE static void do_assign(node_ptr_type p, node_t &other, bool_<true>)
+   inline static void do_assign(node_ptr_type p, node_t &other, bool_<true>)
    {  p->do_move_assign(other.get_real_data());   }
 
-   BOOST_CONTAINER_FORCEINLINE static void do_assign(node_ptr_type p, const node_t &other, bool_<false>)
+   inline static void do_assign(node_ptr_type p, const node_t &other, bool_<false>)
    {  p->do_assign(other.get_real_data());   }
 
    node_ptr_type operator()
@@ -461,19 +461,19 @@ class tree
 
    public:
 
-   BOOST_CONTAINER_FORCEINLINE tree()
+   inline tree()
       : AllocHolder()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp)
+   inline explicit tree(const key_compare& comp)
       : AllocHolder(ValComp(comp))
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a)
+   inline explicit tree(const key_compare& comp, const allocator_type& a)
       : AllocHolder(ValComp(comp), a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const allocator_type& a)
+   inline explicit tree(const allocator_type& a)
       : AllocHolder(a)
    {}
 
@@ -616,19 +616,19 @@ class tree
 
    public:
 
-   BOOST_CONTAINER_FORCEINLINE tree(const tree& x)
+   inline tree(const tree& x)
       :  AllocHolder(x, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
    }
 
-   BOOST_CONTAINER_FORCEINLINE tree(BOOST_RV_REF(tree) x)
+   inline tree(BOOST_RV_REF(tree) x)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       :  AllocHolder(BOOST_MOVE_BASE(AllocHolder, x), x.value_comp())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE tree(const tree& x, const allocator_type &a)
+   inline tree(const tree& x, const allocator_type &a)
       :  AllocHolder(x.value_comp(), a)
    {
       this->icont().clone_from
@@ -649,7 +649,7 @@ class tree
       //AllocHolder clears in case of exception
    }
 
-   BOOST_CONTAINER_FORCEINLINE ~tree()
+   inline ~tree()
    {} //AllocHolder clears the tree
 
    tree& operator=(BOOST_COPY_ASSIGN_REF(tree) x)
@@ -729,56 +729,56 @@ class tree
 
    public:
    // accessors:
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       value_compare value_comp() const
    {  return value_compare(this->key_comp()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       key_compare key_comp() const
    {  return this->icont().key_comp(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       allocator_type get_allocator() const
    {  return allocator_type(this->node_alloc()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const stored_allocator_type &get_stored_allocator() const
    {  return this->node_alloc(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       stored_allocator_type &get_stored_allocator()
    {  return this->node_alloc(); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator begin()
    { return iterator(this->icont().begin()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator begin() const
    {  return this->cbegin();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator end()
    {  return iterator(this->icont().end());  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator end() const
    {  return this->cend();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rbegin()
    {  return reverse_iterator(end());  }
 
    
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rbegin() const
    {  return this->crbegin();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reverse_iterator rend()
    {  return reverse_iterator(begin());   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator rend() const
    {  return this->crend();   }
 
@@ -787,7 +787,7 @@ class tree
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cbegin() const
    { return const_iterator(this->non_const_icont().begin()); }
 
@@ -796,7 +796,7 @@ class tree
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator cend() const
    { return const_iterator(this->non_const_icont().end()); }
 
@@ -806,7 +806,7 @@ class tree
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crbegin() const
    { return const_reverse_iterator(cend()); }
 
@@ -816,23 +816,23 @@ class tree
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reverse_iterator crend() const
    { return const_reverse_iterator(cbegin()); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool empty() const
    {  return !this->size();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type size() const
    {  return this->icont().size();   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type max_size() const
    {  return AllocHolder::max_size();  }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(ThisType& x)
+   inline void swap(ThisType& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    {  AllocHolder::swap(x);   }
@@ -962,11 +962,11 @@ class tree
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
+   inline std::pair<iterator, bool> emplace_unique(BOOST_FWD_REF(Args)... args)
    {  return this->emplace_unique_node(AllocHolder::create_node(boost::forward<Args>(args)...));   }
 
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint_unique(const_iterator hint, BOOST_FWD_REF(Args)... args)
+   inline iterator emplace_hint_unique(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {  return this->emplace_hint_unique_node(hint, AllocHolder::create_node(boost::forward<Args>(args)...));   }
 
    template <class... Args>
@@ -991,7 +991,7 @@ class tree
    }
 
    template <class KeyType, class... Args>
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> try_emplace
+   inline std::pair<iterator, bool> try_emplace
       (const_iterator hint, BOOST_FWD_REF(KeyType) key, BOOST_FWD_REF(Args)... args)
    {
       insert_commit_data data;
@@ -1039,7 +1039,7 @@ class tree
    }\
    \
    template <class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N>\
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool>\
+   inline std::pair<iterator, bool>\
       try_emplace(const_iterator hint, BOOST_FWD_REF(KeyType) key BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       insert_commit_data data;\
@@ -1122,7 +1122,7 @@ class tree
       return iterator(this->icont().erase_and_dispose(position.get(), Destroyer(this->node_alloc())));
    }
 
-   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& k)
+   inline size_type erase(const key_type& k)
    {  return AllocHolder::erase_key(k, alloc_version()); }
 
    size_type erase_unique(const key_type& k)
@@ -1209,105 +1209,105 @@ class tree
    }
 
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge_unique(tree<T, KeyOfValue, C2, Allocator, Options>& source)
+   inline void merge_unique(tree<T, KeyOfValue, C2, Allocator, Options>& source)
    {  return this->icont().merge_unique(source.icont()); }
 
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge_equal(tree<T, KeyOfValue, C2, Allocator, Options>& source)
+   inline void merge_equal(tree<T, KeyOfValue, C2, Allocator, Options>& source)
    {  return this->icont().merge_equal(source.icont());  }
-   BOOST_CONTAINER_FORCEINLINE void clear()
+   inline void clear()
    {  AllocHolder::clear(alloc_version());  }
 
    // search operations. Const and non-const overloads even if no iterator is returned
    // so splay implementations can to their rebalancing when searching in non-const versions
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator find(const key_type& k)
    {  return iterator(this->icont().find(k));  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator find(const key_type& k) const
    {  return const_iterator(this->non_const_icont().find(k));  }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          find(const K& k)
    {  return iterator(this->icont().find(k, KeyNodeCompare()));  }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          find(const K& k) const
    {  return const_iterator(this->non_const_icont().find(k, KeyNodeCompare()));  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type count(const key_type& k) const
    {  return size_type(this->icont().count(k)); }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, size_type>::type
          count(const K& k) const
    {  return size_type(this->icont().count(k, KeyNodeCompare())); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool contains(const key_type& x) const
    {  return this->find(x) != this->cend();  }
 
    template<typename K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, bool>::type
          contains(const K& x) const
    {  return this->find(x) != this->cend();  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator lower_bound(const key_type& k)
    {  return iterator(this->icont().lower_bound(k));  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator lower_bound(const key_type& k) const
    {  return const_iterator(this->non_const_icont().lower_bound(k));  }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          lower_bound(const K& k)
    {  return iterator(this->icont().lower_bound(k, KeyNodeCompare()));  }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          lower_bound(const K& k) const
    {  return const_iterator(this->non_const_icont().lower_bound(k, KeyNodeCompare()));  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator upper_bound(const key_type& k)
    {  return iterator(this->icont().upper_bound(k));   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator upper_bound(const key_type& k) const
    {  return const_iterator(this->non_const_icont().upper_bound(k));  }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          upper_bound(const K& k)
    {  return iterator(this->icont().upper_bound(k, KeyNodeCompare()));   }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          upper_bound(const K& k) const
    {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare()));  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<iterator,iterator> equal_range(const key_type& k)
    {
       std::pair<iiterator, iiterator> ret = this->icont().equal_range(k);
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
    {
       std::pair<iiterator, iiterator> ret =
@@ -1317,7 +1317,7 @@ class tree
    }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, std::pair<iterator,iterator> >::type
          equal_range(const K& k)
    {
@@ -1327,7 +1327,7 @@ class tree
    }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, std::pair<const_iterator, const_iterator> >::type
          equal_range(const K& k) const
    {
@@ -1337,7 +1337,7 @@ class tree
          (const_iterator(ret.first), const_iterator(ret.second));
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<iterator,iterator> lower_bound_range(const key_type& k)
    {
       std::pair<iiterator, iiterator> ret =
@@ -1345,7 +1345,7 @@ class tree
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
    {
       std::pair<iiterator, iiterator> ret =
@@ -1355,7 +1355,7 @@ class tree
    }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, std::pair<iterator,iterator> >::type
          lower_bound_range(const K& k)
    {
@@ -1365,7 +1365,7 @@ class tree
    }
 
    template <class K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, std::pair<const_iterator, const_iterator> >::type
          lower_bound_range(const K& k) const
    {
@@ -1375,34 +1375,34 @@ class tree
          (const_iterator(ret.first), const_iterator(ret.second));
    }
 
-   BOOST_CONTAINER_FORCEINLINE void rebalance()
+   inline void rebalance()
    {  intrusive_tree_proxy_t::rebalance(this->icont());   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator==(const tree& x, const tree& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<(const tree& x, const tree& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=(const tree& x, const tree& y)
    {  return !(x == y);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>(const tree& x, const tree& y)
    {  return y < x;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<=(const tree& x, const tree& y)
    {  return !(y < x);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>=(const tree& x, const tree& y)
    {  return !(x < y);  }
 
-   BOOST_CONTAINER_FORCEINLINE friend void swap(tree& x, tree& y)
+   inline friend void swap(tree& x, tree& y)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    {  x.swap(y);  }
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/value_init.hpp b/contrib/restricted/boost/container/include/boost/container/detail/value_init.hpp
index 35b0aa11d3..08a1f84121 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/value_init.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/value_init.hpp
@@ -31,13 +31,13 @@ namespace dtl {
 template<class T>
 struct value_init
 {
-   value_init()
+   BOOST_CONTAINER_FORCEINLINE value_init()
       : m_t()
    {}
 
-   operator T &() { return m_t; }
+   BOOST_CONTAINER_FORCEINLINE operator T &() { return m_t; }
 
-   T &get() { return m_t; }
+   BOOST_CONTAINER_FORCEINLINE T &get() { return m_t; }
 
    T m_t;
 };
diff --git a/contrib/restricted/boost/container/include/boost/container/detail/workaround.hpp b/contrib/restricted/boost/container/include/boost/container/detail/workaround.hpp
index 64daa0c1d9..23342bb0d1 100644
--- a/contrib/restricted/boost/container/include/boost/container/detail/workaround.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/detail/workaround.hpp
@@ -101,8 +101,11 @@
 #elif defined(BOOST_MSVC) && (_MSC_VER <= 1900 || defined(_DEBUG))
    //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_CONTAINER_FORCEINLINE inline
-#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))
+#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
    //Older GCCs and MinGw have problems with forceinline
+   //Clang can have code bloat issues with forceinline, see
+   //https://lists.boost.org/boost-users/2023/04/91445.php and
+   //https://github.com/llvm/llvm-project/issues/62202
    #define BOOST_CONTAINER_FORCEINLINE inline
 #else
    #define BOOST_CONTAINER_FORCEINLINE BOOST_FORCEINLINE
@@ -187,4 +190,44 @@ BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore(T1 const&)
 #    define BOOST_CONTAINER_CATCH_END }
 #endif
 
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_CONTAINER_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#  else
+#     define BOOST_CONTAINER_STATIC_ASSERT( B ) static_assert(B, #B)
+#  endif
+#else
+namespace boost {
+   namespace container {
+      namespace dtl {
+
+         template<bool B>
+         struct STATIC_ASSERTION_FAILURE;
+
+         template<>
+         struct STATIC_ASSERTION_FAILURE<true> {};
+
+         template<unsigned> struct static_assert_test {};
+
+      }
+   }
+}
+
+#define BOOST_CONTAINER_STATIC_ASSERT(B) \
+         typedef ::boost::container::dtl::static_assert_test<\
+            (unsigned)sizeof(::boost::container::dtl::STATIC_ASSERTION_FAILURE<bool(B)>)>\
+               BOOST_JOIN(boost_container_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_CONTAINER_STATIC_ASSERT_MSG( ... ) static_assert(__VA_ARGS__)
+#  else
+#     define BOOST_CONTAINER_STATIC_ASSERT_MSG( B, Msg ) static_assert( B, Msg )
+#  endif
+#else
+#     define BOOST_CONTAINER_STATIC_ASSERT_MSG( B, Msg ) BOOST_CONTAINER_STATIC_ASSERT( B )
+#endif
+
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP
diff --git a/contrib/restricted/boost/container/include/boost/container/new_allocator.hpp b/contrib/restricted/boost/container/include/boost/container/new_allocator.hpp
index 82c42a957c..b01b9ba8f2 100644
--- a/contrib/restricted/boost/container/include/boost/container/new_allocator.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/new_allocator.hpp
@@ -129,25 +129,23 @@ class new_allocator
 
    //!Default constructor
    //!Never throws
-   new_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   inline new_allocator() BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    //!Constructor from other new_allocator.
    //!Never throws
-   new_allocator(const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline new_allocator(const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    //!Copy assignment operator from other new_allocator.
    //!Never throws
-   new_allocator& operator=(const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
-   {
-       return *this;
-   }
+   inline new_allocator& operator=(const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   {  return *this;  }
 
    //!Constructor from related new_allocator.
    //!Never throws
    template<class T2>
-   new_allocator(const new_allocator<T2> &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline new_allocator(const new_allocator<T2> &) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    //!Allocates memory for an array of count elements.
@@ -174,22 +172,22 @@ class new_allocator
 
    //!Returns the maximum number of elements that could be allocated.
    //!Never throws
-   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return std::size_t(-1)/(2*sizeof(T));   }
 
    //!Swaps two allocators, does nothing
    //!because this new_allocator is stateless
-   friend void swap(new_allocator &, new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend void swap(new_allocator &, new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    //!An new_allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance
-   friend bool operator==(const new_allocator &, const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator==(const new_allocator &, const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return true;   }
 
    //!An new_allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
-   friend bool operator!=(const new_allocator &, const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator!=(const new_allocator &, const new_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 };
 
diff --git a/contrib/restricted/boost/container/include/boost/container/node_handle.hpp b/contrib/restricted/boost/container/include/boost/container/node_handle.hpp
index 323b79c348..41bea974c3 100644
--- a/contrib/restricted/boost/container/include/boost/container/node_handle.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/node_handle.hpp
@@ -21,7 +21,6 @@
 
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/container/detail/placement_new.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/allocator_traits.hpp>
@@ -33,6 +32,12 @@
 #include <boost/container/detail/mpl.hpp>
 #include <boost/assert.hpp>
 
+//GCC 12 is confused about maybe uninitialized allocators
+#if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_GCC < 130000)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
 
 //!\file
 
@@ -60,11 +65,11 @@ class node_handle_friend
    public:
 
    template<class NH>
-   BOOST_CONTAINER_FORCEINLINE static void destroy_alloc(NH &nh) BOOST_NOEXCEPT
+   inline 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
+   inline static typename NH::node_pointer &get_node_pointer(NH &nh) BOOST_NOEXCEPT
    {  return nh.get_node_pointer();  }
 };
 
@@ -252,7 +257,7 @@ class node_handle
    //! <b>Throws</b>: Nothing.
    value_type& value() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((dtl::is_same<KeyMapped, void>::value));
+      BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return m_ptr->get_data();
    }
@@ -267,7 +272,7 @@ class node_handle
    //! <b>Requires</b>: Modifying the key through the returned reference is permitted.
    key_type& key() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
+      BOOST_CONTAINER_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return const_cast<key_type &>(KeyMapped().key_of_value(m_ptr->get_data()));
    }
@@ -280,7 +285,7 @@ class node_handle
    //! <b>Throws</b>: Nothing.
    mapped_type& mapped() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
+      BOOST_CONTAINER_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return KeyMapped().mapped_of_value(m_ptr->get_data());
    }
@@ -299,10 +304,10 @@ class node_handle
    //! <b>Returns</b>: m_ptr != nullptr.
    //!
    #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
-   BOOST_CONTAINER_FORCEINLINE explicit operator bool
+   inline explicit operator bool
    #else
    private: struct bool_conversion {int for_bool; int for_arg(); }; typedef int bool_conversion::* explicit_bool_arg;
-   public: BOOST_CONTAINER_FORCEINLINE operator explicit_bool_arg
+   public: inline operator explicit_bool_arg
    #endif
       ()const BOOST_NOEXCEPT
    {  return m_ptr ? &bool_conversion::for_bool  : explicit_bool_arg(0);  }
@@ -343,6 +348,7 @@ class node_handle
          nh.move_construct_alloc(this->node_alloc());
          this->destroy_alloc();
       }
+
       ::boost::adl_move_swap(m_ptr, nh.m_ptr);
    }
 
@@ -440,6 +446,10 @@ struct insert_return_type_base
 }  //namespace container {
 }  //namespace boost {
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_GCC < 130000)
+#pragma GCC diagnostic pop
+#endif
+
 #include <boost/container/detail/config_end.hpp>
 
 #endif   //BOOST_CONTAINER_NODE_HANDLE_HPP
diff --git a/contrib/restricted/boost/container/include/boost/container/options.hpp b/contrib/restricted/boost/container/include/boost/container/options.hpp
index c58ff82a22..48edd38197 100644
--- a/contrib/restricted/boost/container/include/boost/container/options.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/options.hpp
@@ -23,8 +23,8 @@
 
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/container_fwd.hpp>
+#include <boost/container/detail/workaround.hpp>
 #include <boost/intrusive/pack_options.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace container {
@@ -608,7 +608,7 @@ struct deque_opt
 {
    static const std::size_t block_bytes = BlockBytes;
    static const std::size_t block_size  = BlockSize;
-   BOOST_STATIC_ASSERT_MSG(!(block_bytes && block_size), "block_bytes and block_size can't be specified at the same time");
+   BOOST_CONTAINER_STATIC_ASSERT_MSG(!(block_bytes && block_size), "block_bytes and block_size can't be specified at the same time");
 };
 
 typedef deque_opt<0u, 0u> deque_null_opt;
diff --git a/contrib/restricted/boost/container/include/boost/container/scoped_allocator.hpp b/contrib/restricted/boost/container/include/boost/container/scoped_allocator.hpp
index 3e9c6847a2..a979ad658a 100644
--- a/contrib/restricted/boost/container/include/boost/container/scoped_allocator.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/scoped_allocator.hpp
@@ -77,10 +77,10 @@ struct outermost_allocator_imp
 {
    typedef MaybeScopedAlloc type;
 
-   BOOST_CONTAINER_FORCEINLINE static type &get(MaybeScopedAlloc &a)
+   inline static type &get(MaybeScopedAlloc &a)
    {  return a;  }
 
-   BOOST_CONTAINER_FORCEINLINE static const type &get(const MaybeScopedAlloc &a)
+   inline static const type &get(const MaybeScopedAlloc &a)
    {  return a;  }
 };
 
@@ -90,10 +90,10 @@ struct outermost_allocator_imp<MaybeScopedAlloc, true>
    typedef typename MaybeScopedAlloc::outer_allocator_type outer_type;
    typedef typename outermost_allocator_type_impl<outer_type>::type type;
 
-   BOOST_CONTAINER_FORCEINLINE static type &get(MaybeScopedAlloc &a)
+   inline static type &get(MaybeScopedAlloc &a)
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 
-   BOOST_CONTAINER_FORCEINLINE static const type &get(const MaybeScopedAlloc &a)
+   inline static const type &get(const MaybeScopedAlloc &a)
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 };
 
@@ -110,12 +110,12 @@ struct outermost_allocator
 {};
 
 template <typename Allocator>
-BOOST_CONTAINER_FORCEINLINE typename outermost_allocator<Allocator>::type &
+inline typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
 template <typename Allocator>
-BOOST_CONTAINER_FORCEINLINE const typename outermost_allocator<Allocator>::type &
+inline const typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(const Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
@@ -159,34 +159,34 @@ class scoped_allocator_adaptor_base
       inner_allocator_type::is_always_equal::value
       > is_always_equal;
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base()
+   inline scoped_allocator_adaptor_base()
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs &...args)
+   inline scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs &...args)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       , m_inner(args...)
       {}
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
+   inline scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
       : outer_allocator_type(other.outer_allocator())
       , m_inner(other.inner_allocator())
       {}
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   inline scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
       : outer_allocator_type(::boost::move(other.outer_allocator()))
       , m_inner(::boost::move(other.inner_allocator()))
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
+   inline scoped_allocator_adaptor_base
       (const scoped_allocator_adaptor_base<OuterA2, InnerAllocs...>& other)
       : outer_allocator_type(other.outer_allocator())
       , m_inner(other.inner_allocator())
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
+   inline scoped_allocator_adaptor_base
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base
          <OuterA2, InnerAllocs...> BOOST_RV_REF_END other)
       : outer_allocator_type(other.outer_allocator())
@@ -197,7 +197,7 @@ class scoped_allocator_adaptor_base
    struct internal_type_t{};
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
+   inline scoped_allocator_adaptor_base
       ( internal_type_t
       , BOOST_FWD_REF(OuterA2) outerAlloc
       , const inner_allocator_type &inner)
@@ -207,7 +207,7 @@ class scoped_allocator_adaptor_base
 
    public:
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=
+   inline scoped_allocator_adaptor_base &operator=
       (BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(other.outer_allocator());
@@ -215,35 +215,35 @@ class scoped_allocator_adaptor_base
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   inline scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));
       m_inner = ::boost::move(other.inner_allocator());
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)
+   inline void swap(scoped_allocator_adaptor_base &r)
    {
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());
       boost::adl_move_swap(this->m_inner, r.inner_allocator());
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
+   inline friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
    {  l.swap(r);  }
 
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   inline inner_allocator_type&       inner_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return m_inner; }
 
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline inner_allocator_type const& inner_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_inner; }
 
-   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   inline outer_allocator_type      & outer_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return static_cast<outer_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const outer_allocator_type &outer_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return static_cast<const outer_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const
+   inline scoped_allocator_type select_on_container_copy_construction() const
    {
       return scoped_allocator_type
          (internal_type_t()
@@ -302,33 +302,33 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
       inner_allocator_type::is_always_equal::value\
       > is_always_equal;\
    \
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(){}\
+   inline scoped_allocator_adaptor_base(){}\
    \
    template <class OuterA2>\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, BOOST_MOVE_CREF##N)\
+   inline scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc, BOOST_MOVE_CREF##N)\
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))\
       , m_inner(BOOST_MOVE_ARG##N)\
       {}\
    \
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)\
+   inline scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
       {}\
    \
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
+   inline scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
       : outer_allocator_type(::boost::move(other.outer_allocator()))\
       , m_inner(::boost::move(other.inner_allocator()))\
       {}\
    \
    template <class OuterA2>\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
+   inline scoped_allocator_adaptor_base\
       (const scoped_allocator_adaptor_base<OuterA2, true, BOOST_MOVE_TARG##N>& other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
       {}\
    \
    template <class OuterA2>\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
+   inline scoped_allocator_adaptor_base\
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base<OuterA2, true, BOOST_MOVE_TARG##N> BOOST_RV_REF_END other)\
       : outer_allocator_type(other.outer_allocator())\
       , m_inner(other.inner_allocator())\
@@ -338,14 +338,14 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
    struct internal_type_t{};\
    \
    template <class OuterA2>\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base\
+   inline scoped_allocator_adaptor_base\
       ( internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &inner)\
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))\
       , m_inner(inner)\
    {}\
    \
    public:\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=\
+   inline scoped_allocator_adaptor_base &operator=\
       (BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)\
    {\
       outer_allocator_type::operator=(other.outer_allocator());\
@@ -353,35 +353,35 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
       return *this;\
    }\
    \
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
+   inline scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)\
    {\
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));\
       m_inner = ::boost::move(other.inner_allocator());\
       return *this;\
    }\
    \
-   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)\
+   inline void swap(scoped_allocator_adaptor_base &r)\
    {\
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());\
       boost::adl_move_swap(this->m_inner, r.inner_allocator());\
    }\
    \
-   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)\
+   inline friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)\
    {  l.swap(r);  }\
    \
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator()\
+   inline inner_allocator_type&       inner_allocator()\
       { return m_inner; }\
    \
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const\
+   inline inner_allocator_type const& inner_allocator() const\
       { return m_inner; }\
    \
-   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator()\
+   inline outer_allocator_type      & outer_allocator()\
       { return static_cast<outer_allocator_type&>(*this); }\
    \
-   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const\
+   inline const outer_allocator_type &outer_allocator() const\
       { return static_cast<const outer_allocator_type&>(*this); }\
    \
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const\
+   inline scoped_allocator_type select_on_container_copy_construction() const\
    {\
       return scoped_allocator_type\
          (internal_type_t()\
@@ -438,30 +438,30 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    typedef typename outer_traits_type::
       is_always_equal                           is_always_equal;
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base()
+   inline scoped_allocator_adaptor_base()
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc)
+   inline scoped_allocator_adaptor_base(BOOST_FWD_REF(OuterA2) outerAlloc)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       {}
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
+   inline scoped_allocator_adaptor_base(const scoped_allocator_adaptor_base& other)
       : outer_allocator_type(other.outer_allocator())
       {}
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   inline scoped_allocator_adaptor_base(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
       : outer_allocator_type(::boost::move(other.outer_allocator()))
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
+   inline scoped_allocator_adaptor_base
       (const scoped_allocator_adaptor_base<OuterA2 BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE>& other)
       : outer_allocator_type(other.outer_allocator())
       {}
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base
+   inline scoped_allocator_adaptor_base
       (BOOST_RV_REF_BEG scoped_allocator_adaptor_base<OuterA2 BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE> BOOST_RV_REF_END other)
       : outer_allocator_type(other.outer_allocator())
       {}
@@ -470,44 +470,44 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    struct internal_type_t{};
 
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base(internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &)
+   inline scoped_allocator_adaptor_base(internal_type_t, BOOST_FWD_REF(OuterA2) outerAlloc, const inner_allocator_type &)
       : outer_allocator_type(::boost::forward<OuterA2>(outerAlloc))
       {}
 
    public:
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
+   inline scoped_allocator_adaptor_base &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(other.outer_allocator());
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
+   inline scoped_allocator_adaptor_base &operator=(BOOST_RV_REF(scoped_allocator_adaptor_base) other)
    {
       outer_allocator_type::operator=(boost::move(other.outer_allocator()));
       return *this;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(scoped_allocator_adaptor_base &r)
+   inline void swap(scoped_allocator_adaptor_base &r)
    {
       boost::adl_move_swap(this->outer_allocator(), r.outer_allocator());
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
+   inline friend void swap(scoped_allocator_adaptor_base &l, scoped_allocator_adaptor_base &r)
    {  l.swap(r);  }
 
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type&       inner_allocator()
+   inline inner_allocator_type&       inner_allocator()
       { return static_cast<inner_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE inner_allocator_type const& inner_allocator() const
+   inline inner_allocator_type const& inner_allocator() const
       { return static_cast<const inner_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE outer_allocator_type      & outer_allocator()
+   inline outer_allocator_type      & outer_allocator()
       { return static_cast<outer_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE const outer_allocator_type &outer_allocator() const
+   inline const outer_allocator_type &outer_allocator() const
       { return static_cast<const outer_allocator_type&>(*this); }
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_type select_on_container_copy_construction() const
+   inline scoped_allocator_type select_on_container_copy_construction() const
    {
       return scoped_allocator_type
          (internal_type_t()
@@ -639,21 +639,21 @@ class scoped_allocator_adaptor
 
    //! <b>Effects</b>: value-initializes the OuterAlloc base class
    //! and the inner allocator object.
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor()
+   inline scoped_allocator_adaptor()
       {}
 
-   BOOST_CONTAINER_FORCEINLINE ~scoped_allocator_adaptor()
+   inline ~scoped_allocator_adaptor()
       {}
 
    //! <b>Effects</b>: initializes each allocator within the adaptor with
    //! the corresponding allocator from other.
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(const scoped_allocator_adaptor& other)
+   inline scoped_allocator_adaptor(const scoped_allocator_adaptor& other)
       : base_type(other.base())
       {}
 
    //! <b>Effects</b>: move constructs each allocator within the adaptor with
    //! the corresponding allocator from other.
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_RV_REF(scoped_allocator_adaptor) other)
+   inline scoped_allocator_adaptor(BOOST_RV_REF(scoped_allocator_adaptor) other)
       : base_type(::boost::move(other.base()))
       {}
 
@@ -665,14 +665,14 @@ class scoped_allocator_adaptor
    //! with innerAllocs...(hence recursively initializing each allocator within the adaptor with the
    //! corresponding allocator from the argument list).
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs & ...innerAllocs)
+   inline scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc, const InnerAllocs & ...innerAllocs)
       : base_type(::boost::forward<OuterA2>(outerAlloc), innerAllocs...)
       {}
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    #define BOOST_CONTAINER_SCOPED_ALLOCATOR_ADAPTOR_RELATED_ALLOCATOR_CONSTRUCTOR_CODE(N)\
    template <class OuterA2>\
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc BOOST_MOVE_I##N BOOST_MOVE_CREF##N)\
+   inline scoped_allocator_adaptor(BOOST_FWD_REF(OuterA2) outerAlloc BOOST_MOVE_I##N BOOST_MOVE_CREF##N)\
       : base_type(::boost::forward<OuterA2>(outerAlloc) BOOST_MOVE_I##N BOOST_MOVE_ARG##N)\
       {}\
    //
@@ -685,7 +685,7 @@ class scoped_allocator_adaptor
    //!
    //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator from other.
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> &other)
+   inline scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> &other)
       : base_type(other.base())
       {}
 
@@ -694,15 +694,15 @@ class scoped_allocator_adaptor
    //! <b>Effects</b>: initializes each allocator within the adaptor with the corresponding allocator
    //! rvalue from other.
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(BOOST_RV_REF_BEG scoped_allocator_adaptor
+   inline scoped_allocator_adaptor(BOOST_RV_REF_BEG scoped_allocator_adaptor
       <OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> BOOST_RV_REF_END other)
       : base_type(::boost::move(other.base()))
       {}
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor) other)
+   inline scoped_allocator_adaptor &operator=(BOOST_COPY_ASSIGN_REF(scoped_allocator_adaptor) other)
    {  return static_cast<scoped_allocator_adaptor&>(base_type::operator=(static_cast<const base_type &>(other))); }
 
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor &operator=(BOOST_RV_REF(scoped_allocator_adaptor) other)
+   inline scoped_allocator_adaptor &operator=(BOOST_RV_REF(scoped_allocator_adaptor) other)
    {  return static_cast<scoped_allocator_adaptor&>(base_type::operator=(boost::move(other.base()))); }
 
    #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -734,13 +734,13 @@ class scoped_allocator_adaptor
 
    //! <b>Returns</b>:
    //!   <code>allocator_traits<OuterAlloc>:: max_size(outer_allocator())</code>.
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return outer_traits_type::max_size(this->outer_allocator());   }
 
    //! <b>Effects</b>:
    //!   calls <code>OUTERMOST_ALLOC_TRAITS(*this):: destroy(OUTERMOST(*this), p)</code>.
    template <class T>
-   BOOST_CONTAINER_FORCEINLINE void destroy(T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void destroy(T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       allocator_traits<typename outermost_allocator<OuterAlloc>::type>
          ::destroy(get_outermost_allocator(this->outer_allocator()), p);
@@ -748,17 +748,17 @@ class scoped_allocator_adaptor
 
    //! <b>Returns</b>:
    //! <code>allocator_traits<OuterAlloc>::allocate(outer_allocator(), n)</code>.
-   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n)
+   inline pointer allocate(size_type n)
    {  return outer_traits_type::allocate(this->outer_allocator(), n);   }
 
    //! <b>Returns</b>:
    //! <code>allocator_traits<OuterAlloc>::allocate(outer_allocator(), n, hint)</code>.
-   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n, const_void_pointer hint)
+   inline pointer allocate(size_type n, const_void_pointer hint)
    {  return outer_traits_type::allocate(this->outer_allocator(), n, hint);   }
 
    //! <b>Effects</b>:
    //! <code>allocator_traits<OuterAlloc>::deallocate(outer_allocator(), p, n)</code>.
-   BOOST_CONTAINER_FORCEINLINE void deallocate(pointer p, size_type n)
+   inline void deallocate(pointer p, size_type n)
    {  outer_traits_type::deallocate(this->outer_allocator(), p, n);  }
 
    #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -770,9 +770,9 @@ class scoped_allocator_adaptor
    #endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   BOOST_CONTAINER_FORCEINLINE base_type &base()             { return *this; }
+   inline base_type &base()             { return *this; }
 
-   BOOST_CONTAINER_FORCEINLINE const base_type &base() const { return *this; }
+   inline const base_type &base() const { return *this; }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -806,7 +806,7 @@ class scoped_allocator_adaptor
    //! to true but the specific constructor does not take an allocator. This definition prevents a silent
    //! failure to pass an inner allocator to a contained element. -end note]
    template < typename T, class ...Args>
-   BOOST_CONTAINER_FORCEINLINE void construct(T* p, BOOST_FWD_REF(Args)...args)
+   inline void construct(T* p, BOOST_FWD_REF(Args)...args)
    {
       dtl::dispatch_uses_allocator
          ( (get_outermost_allocator)(this->outer_allocator())
@@ -819,7 +819,7 @@ class scoped_allocator_adaptor
    //overload selection problems when the first parameter is a pair.
    #define BOOST_CONTAINER_SCOPED_ALLOCATOR_CONSTRUCT_CODE(N) \
    template < typename T BOOST_MOVE_I##N BOOST_MOVE_CLASSQ##N >\
-   BOOST_CONTAINER_FORCEINLINE void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
+   inline void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
       dtl::dispatch_uses_allocator\
          ( (get_outermost_allocator)(this->outer_allocator())\
@@ -836,7 +836,7 @@ class scoped_allocator_adaptor
    public:
    //Internal function
    template <class OuterA2>
-   BOOST_CONTAINER_FORCEINLINE scoped_allocator_adaptor(internal_type_t, BOOST_FWD_REF(OuterA2) outer, const inner_allocator_type& inner)
+   inline scoped_allocator_adaptor(internal_type_t, BOOST_FWD_REF(OuterA2) outer, const inner_allocator_type& inner)
       : base_type(internal_type_t(), ::boost::forward<OuterA2>(outer), inner)
    {}
 
@@ -851,17 +851,17 @@ struct scoped_allocator_operator_equal
    //Optimize equal outer allocator types with 
    //allocator_traits::equal which uses is_always_equal
    template<class IA>
-   BOOST_CONTAINER_FORCEINLINE static bool equal_outer(const IA &l, const IA &r)
+   inline static bool equal_outer(const IA &l, const IA &r)
    {  return allocator_traits<IA>::equal(l, r);  }
 
    //Otherwise compare it normally
    template<class IA1, class IA2>
-   BOOST_CONTAINER_FORCEINLINE static bool equal_outer(const IA1 &l, const IA2 &r)
+   inline static bool equal_outer(const IA1 &l, const IA2 &r)
    {  return l == r;  }
 
    //Otherwise compare it normally
    template<class IA>
-   BOOST_CONTAINER_FORCEINLINE static bool equal_inner(const IA &l, const IA &r)
+   inline static bool equal_inner(const IA &l, const IA &r)
    {  return allocator_traits<IA>::equal(l, r);  }
 };
 
@@ -873,14 +873,14 @@ struct scoped_allocator_operator_equal<true>
    //inner_allocator_type is the same as outer_allocator_type
    //so both types can be different in operator==
    template<class IA1, class IA2>
-   BOOST_CONTAINER_FORCEINLINE static bool equal_inner(const IA1 &, const IA2 &)
+   inline static bool equal_inner(const IA1 &, const IA2 &)
    {  return true;  }
 };
 
 /// @endcond
 
 template <typename OuterA1, typename OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS>
-BOOST_CONTAINER_FORCEINLINE bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
+inline bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
                       ,const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& b)
 {
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -894,7 +894,7 @@ BOOST_CONTAINER_FORCEINLINE bool operator==(const scoped_allocator_adaptor<Outer
 }
 
 template <typename OuterA1, typename OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNERCLASS>
-BOOST_CONTAINER_FORCEINLINE bool operator!=(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
+inline bool operator!=(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& a
                       ,const scoped_allocator_adaptor<OuterA2, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>& b)
 {  return !(a == b);   }
 
diff --git a/contrib/restricted/boost/container/include/boost/container/set.hpp b/contrib/restricted/boost/container/include/boost/container/set.hpp
index f8a2efad2f..1aef8ff002 100644
--- a/contrib/restricted/boost/container/include/boost/container/set.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/set.hpp
@@ -113,7 +113,7 @@ class set
    //!
    //! <b>Complexity</b>: Constant.
    
-   BOOST_CONTAINER_FORCEINLINE set()
+   inline set()
       BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<allocator_type>::value &&
                         dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
@@ -122,14 +122,14 @@ class set
    //! <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)
+   inline 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)
+   inline explicit set(const Compare& comp)
       : base_t(comp)
    {}
 
@@ -137,7 +137,7 @@ class set
    //! and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE set(const Compare& comp, const allocator_type& a)
+   inline set(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
    {}
 
@@ -147,7 +147,7 @@ class set
    //! <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)
+   inline set(InputIterator first, InputIterator last)
       : base_t(true, first, last)
    {}
 
@@ -157,7 +157,7 @@ class set
    //! <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 allocator_type& a)
+   inline set(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(true, first, last, key_compare(), a)
    {}
 
@@ -167,7 +167,7 @@ class set
    //! <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)
+   inline set(InputIterator first, InputIterator last, const Compare& comp)
       : base_t(true, first, last, comp)
    {}
 
@@ -177,7 +177,7 @@ class set
    //! <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)
+   inline set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(true, first, last, comp, a)
    {}
 
@@ -192,7 +192,7 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last)
+   inline set( ordered_unique_range_t, InputIterator first, InputIterator last)
       : base_t(ordered_range, first, last)
    {}
 
@@ -207,7 +207,7 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp )
+   inline set( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp )
       : base_t(ordered_range, first, last, comp)
    {}
 
@@ -222,7 +222,7 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last
+   inline set( ordered_unique_range_t, InputIterator first, InputIterator last
       , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
@@ -238,7 +238,7 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE set(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
+   inline set(ordered_unique_range_t, InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(ordered_range, first, last, Compare(), a)
    {}
 
@@ -248,7 +248,7 @@ class set
    //!
    //! <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)
+   inline set(std::initializer_list<value_type> il)
       : base_t(true, il.begin(), il.end())
    {}
 
@@ -257,7 +257,7 @@ class set
    //!
    //! <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 allocator_type& a)
+   inline set(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), Compare(), a)
    {}
 
@@ -266,7 +266,7 @@ class set
    //!
    //! <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 )
+   inline set(std::initializer_list<value_type> il, const Compare& comp )
       : base_t(true, il.begin(), il.end(), comp)
    {}
 
@@ -275,7 +275,7 @@ class set
    //!
    //! <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)
+   inline set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), comp, a)
    {}
 
@@ -289,7 +289,7 @@ class set
    //! <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)
+   inline set( ordered_unique_range_t, std::initializer_list<value_type> il)
       : base_t(ordered_range, il.begin(), il.end())
    {}
 
@@ -303,7 +303,7 @@ class set
    //! <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)
+   inline set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
       : base_t(ordered_range, il.begin(), il.end(), comp)
    {}
 
@@ -317,7 +317,7 @@ class set
    //! <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, const allocator_type& a)
+   inline 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
@@ -325,7 +325,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE set(const set& x)
+   inline set(const set& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
@@ -334,7 +334,7 @@ class set
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x)
+   inline set(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
@@ -342,7 +342,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE set(const set& x, const allocator_type &a)
+   inline set(const set& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
@@ -350,14 +350,14 @@ class set
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x, const allocator_type &a)
+   inline 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().
-   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
+   inline 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()).
@@ -368,7 +368,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.
-   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_RV_REF(set) x)
+   inline 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::dtl::is_nothrow_move_assignable<Compare>::value)
@@ -541,7 +541,7 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   inline 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
@@ -554,18 +554,18 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   inline 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 \
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   inline 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 \
-   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   inline 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)
@@ -632,7 +632,7 @@ class set
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
+   inline void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_unique_range(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -640,21 +640,21 @@ 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())
-   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   inline void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_unique_range(il.begin(), il.end()); }
 #endif
 
    //! @copydoc ::boost::container::map::insert(node_type&&)
-   BOOST_CONTAINER_FORCEINLINE insert_return_type insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   inline 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&&)
-   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)
+   inline 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>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(set<Key, C2, Allocator, Options>& source)
+   inline void merge(set<Key, C2, Allocator, Options>& source)
    {
       typedef dtl::tree
          <Key, void, C2, Allocator, Options> base2_t;
@@ -663,12 +663,12 @@ class set
 
    //! @copydoc ::boost::container::set::merge(set<Key, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG set<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
+   inline void merge(BOOST_RV_REF_BEG set<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<set<Key, C2, Allocator, Options>&>(source));   }
 
    //! @copydoc ::boost::container::map::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(multiset<Key, C2, Allocator, Options>& source)
+   inline void merge(multiset<Key, C2, Allocator, Options>& source)
    {
       typedef dtl::tree
          <Key, void, C2, Allocator, Options> base2_t;
@@ -677,7 +677,7 @@ class set
 
    //! @copydoc ::boost::container::set::merge(multiset<Key, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG multiset<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
+   inline void merge(BOOST_RV_REF_BEG multiset<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<multiset<Key, C2, Allocator, Options>&>(source));   }
 
    //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
@@ -685,7 +685,7 @@ class set
    //! <b>Returns</b>: Returns the number of erased elements (0/1).
    //!
    //! <b>Complexity</b>: log(size()) + count(k)
-   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
+   inline size_type erase(const key_type& x)
    {  return this->base_t::erase_unique(x);   }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -779,7 +779,7 @@ class set
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type count(const key_type& x) const
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend());  }
 
@@ -790,7 +790,7 @@ class set
    //!
    //! <b>Complexity</b>: log(size())+count(k)
    template<typename K>
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type count(const K& x) const
    {  return static_cast<size_type>(this->find(x) != this->cend());  }
 
@@ -881,13 +881,13 @@ class set
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
+   inline 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
-   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+   inline std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
    {  return this->base_t::lower_bound_range(x);  }
 
    //! <b>Requires</b>: This overload is available only if
@@ -897,7 +897,7 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic
    template<typename K>
-   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const K& x)
+   inline std::pair<iterator,iterator> equal_range(const K& x)
    {  return this->base_t::lower_bound_range(x);  }
 
    //! <b>Requires</b>: This overload is available only if
@@ -907,7 +907,7 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic
    template<typename K>
-   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator,const_iterator> equal_range(const K& x) const
+   inline std::pair<const_iterator,const_iterator> equal_range(const K& x) const
    {  return this->base_t::lower_bound_range(x);  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1097,48 +1097,48 @@ class multiset
    //////////////////////////////////////////////
 
    //! @copydoc ::boost::container::set::set()
-   BOOST_CONTAINER_FORCEINLINE multiset()
+   inline multiset()
       BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<allocator_type>::value &&
                         dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
    //! @copydoc ::boost::container::set::set(const allocator_type&)
-   BOOST_CONTAINER_FORCEINLINE explicit multiset(const allocator_type& a)
+   inline explicit multiset(const allocator_type& a)
       : base_t(a)
    {}
 
    //! @copydoc ::boost::container::set::set(const Compare&)
-   BOOST_CONTAINER_FORCEINLINE explicit multiset(const Compare& comp)
+   inline 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)
+   inline multiset(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
    {}
 
    //! @copydoc ::boost::container::set::set(InputIterator, InputIterator)
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last)
+   inline multiset(InputIterator first, InputIterator last)
       : base_t(false, first, last)
    {}
 
    //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const allocator_type&)
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const allocator_type& a)
+   inline 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)
+   inline 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)
+   inline multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(false, first, last, comp, a)
    {}
 
@@ -1152,7 +1152,7 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last )
+   inline multiset( ordered_range_t, InputIterator first, InputIterator last )
       : base_t(ordered_range, first, last)
    {}
 
@@ -1166,7 +1166,7 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+   inline multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
       : base_t(ordered_range, first, last, comp)
    {}
 
@@ -1180,7 +1180,7 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+   inline multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
@@ -1194,74 +1194,74 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, InputIterator first, InputIterator last, const allocator_type &a)
+   inline multiset(ordered_range_t, InputIterator first, InputIterator last, const allocator_type &a)
       : base_t(ordered_range, first, last, Compare(), a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>)
-   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il)
+   inline 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&)
-   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const allocator_type& a)
+   inline 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(std::initializer_list<value_type>, const Compare&)
-   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const Compare& comp)
+   inline 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)
+   inline 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)
+   inline 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)
+   inline 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)
+   inline 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 &)
-   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x)
+   inline multiset(const multiset& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
    //! @copydoc ::boost::container::set::set(set &&)
-   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x)
+   inline multiset(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
    //! @copydoc ::boost::container::set::set(const set &, const allocator_type &)
-   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x, const allocator_type &a)
+   inline 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 &)
-   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
+   inline 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 &)
-   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
+   inline 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 &&)
-   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x)
+   inline 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::dtl::is_nothrow_move_assignable<Compare>::value)
@@ -1342,7 +1342,7 @@ class multiset
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_FWD_REF(Args)... args)
+   inline 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
@@ -1354,18 +1354,18 @@ class multiset
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   inline 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 \
-   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
+   inline 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 \
-   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   inline 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)
@@ -1423,26 +1423,26 @@ class multiset
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
+   inline void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_equal_range(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! @copydoc ::boost::container::set::insert(std::initializer_list<value_type>)
-   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
+   inline void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_equal_range(il.begin(), il.end());  }
 #endif
 
    //! @copydoc ::boost::container::multimap::insert(node_type&&)
-   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   inline 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&&)
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   inline 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>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(multiset<Key, C2, Allocator, Options>& source)
+   inline void merge(multiset<Key, C2, Allocator, Options>& source)
    {
       typedef dtl::tree
          <Key, void, C2, Allocator, Options> base2_t;
@@ -1451,12 +1451,12 @@ class multiset
 
    //! @copydoc ::boost::container::multiset::merge(multiset<Key, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG multiset<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
+   inline void merge(BOOST_RV_REF_BEG multiset<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<multiset<Key, C2, Allocator, Options>&>(source));   }
 
    //! @copydoc ::boost::container::multimap::merge(map<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(set<Key, C2, Allocator, Options>& source)
+   inline void merge(set<Key, C2, Allocator, Options>& source)
    {
       typedef dtl::tree
          <Key, void, C2, Allocator, Options> base2_t;
@@ -1465,7 +1465,7 @@ class multiset
 
    //! @copydoc ::boost::container::multiset::merge(set<Key, C2, Allocator, Options>&)
    template<class C2>
-   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG set<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
+   inline void merge(BOOST_RV_REF_BEG set<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<set<Key, C2, Allocator, Options>&>(source));   }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
diff --git a/contrib/restricted/boost/container/include/boost/container/small_vector.hpp b/contrib/restricted/boost/container/include/boost/container/small_vector.hpp
index 66b31954d7..28adc46b88 100644
--- a/contrib/restricted/boost/container/include/boost/container/small_vector.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/small_vector.hpp
@@ -46,6 +46,8 @@
 #include <initializer_list>   //for std::initializer_list
 #endif
 
+#include <cstddef> //offsetof
+
 namespace boost {
 namespace container {
 
@@ -130,10 +132,10 @@ class small_vector_allocator
 
    BOOST_COPYABLE_AND_MOVABLE(small_vector_allocator)
 
-   BOOST_CONTAINER_FORCEINLINE const allocator_type &as_base() const BOOST_NOEXCEPT
+   inline const allocator_type &as_base() const BOOST_NOEXCEPT
    {  return static_cast<const allocator_type&>(*this);  }
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type &as_base() BOOST_NOEXCEPT
+   inline allocator_type &as_base() BOOST_NOEXCEPT
    {  return static_cast<allocator_type&>(*this);  }
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -171,19 +173,19 @@ class small_vector_allocator
       typedef typename allocator_traits<allocator_type>::template portable_rebind_alloc<T2>::type other;
    };
 
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<allocator_type>::value)
+   inline small_vector_allocator() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<allocator_type>::value)
    {}
 
    //!Constructor from other small_vector_allocator.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator
+   inline small_vector_allocator
       (const small_vector_allocator &other) BOOST_NOEXCEPT_OR_NOTHROW
       : allocator_type(other.as_base())
    {}
 
    //!Move constructor from small_vector_allocator.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator
+   inline small_vector_allocator
       (BOOST_RV_REF(small_vector_allocator) other) BOOST_NOEXCEPT_OR_NOTHROW
       : allocator_type(::boost::move(other.as_base()))
    {}
@@ -191,7 +193,7 @@ class small_vector_allocator
    //!Constructor from related small_vector_allocator.
    //!Never throws
    template<class U, class OtherVoidAllocator, class OtherOptions>
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator
+   inline small_vector_allocator
       (const small_vector_allocator<U, OtherVoidAllocator, OtherOptions> &other) BOOST_NOEXCEPT_OR_NOTHROW
       : allocator_type(other.as_base())
    {}
@@ -199,52 +201,52 @@ class small_vector_allocator
    //!Move constructor from related small_vector_allocator.
    //!Never throws
    template<class U, class OtherVoidAllocator, class OtherOptions>
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator
+   inline small_vector_allocator
       (BOOST_RV_REF(small_vector_allocator<U BOOST_MOVE_I OtherVoidAllocator BOOST_MOVE_I OtherOptions>) other) BOOST_NOEXCEPT_OR_NOTHROW
       : allocator_type(::boost::move(other.as_base()))
    {}
 
    //!Constructor from allocator_type.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector_allocator
+   inline explicit small_vector_allocator
       (const allocator_type &other) BOOST_NOEXCEPT_OR_NOTHROW
       : allocator_type(other)
    {}
 
    //!Assignment from other small_vector_allocator.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator &
+   inline small_vector_allocator &
       operator=(BOOST_COPY_ASSIGN_REF(small_vector_allocator) other) BOOST_NOEXCEPT_OR_NOTHROW
    {  return static_cast<small_vector_allocator&>(this->allocator_type::operator=(other.as_base()));  }
 
    //!Move assignment from other small_vector_allocator.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator &
+   inline small_vector_allocator &
       operator=(BOOST_RV_REF(small_vector_allocator) other) BOOST_NOEXCEPT_OR_NOTHROW
    {  return static_cast<small_vector_allocator&>(this->allocator_type::operator=(::boost::move(other.as_base())));  }
 
    //!Assignment from related small_vector_allocator.
    //!Never throws
    template<class U, class OtherVoidAllocator>
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator &
+   inline small_vector_allocator &
       operator=(BOOST_COPY_ASSIGN_REF(small_vector_allocator<U BOOST_MOVE_I OtherVoidAllocator BOOST_MOVE_I Options>) other) BOOST_NOEXCEPT_OR_NOTHROW
    {  return static_cast<small_vector_allocator&>(this->allocator_type::operator=(other.as_base()));  }
 
    //!Move assignment from related small_vector_allocator.
    //!Never throws
    template<class U, class OtherVoidAllocator>
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator &
+   inline small_vector_allocator &
       operator=(BOOST_RV_REF(small_vector_allocator<U BOOST_MOVE_I OtherVoidAllocator BOOST_MOVE_I Options>) other) BOOST_NOEXCEPT_OR_NOTHROW
    {  return static_cast<small_vector_allocator&>(this->allocator_type::operator=(::boost::move(other.as_base())));  }
 
    //!Move assignment from allocator_type.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE small_vector_allocator &
+   inline small_vector_allocator &
       operator=(const allocator_type &other) BOOST_NOEXCEPT_OR_NOTHROW
    {  return static_cast<small_vector_allocator&>(this->allocator_type::operator=(other));  }
 
    //!Allocates storage from the standard-conforming allocator
-   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type count, const_void_pointer hint = const_void_pointer())
+   inline pointer allocate(size_type count, const_void_pointer hint = const_void_pointer())
    {  return allocator_traits_type::allocate(this->as_base(), count, hint);  }
 
    //!Deallocates previously allocated memory.
@@ -257,7 +259,7 @@ class small_vector_allocator
 
    //!Returns the maximum number of elements that could be allocated.
    //!Never throws
-   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_traits_type::max_size(this->as_base());   }
 
    small_vector_allocator select_on_container_copy_construction() const
@@ -268,17 +270,17 @@ class small_vector_allocator
 
    //!Swaps two allocators, does nothing
    //!because this small_vector_allocator is stateless
-   BOOST_CONTAINER_FORCEINLINE friend void swap(small_vector_allocator &l, small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend void swap(small_vector_allocator &l, small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
    {  boost::adl_move_swap(l.as_base(), r.as_base());  }
 
    //!An small_vector_allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance (except for unpropagable storage)
-   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const small_vector_allocator &l, const small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator==(const small_vector_allocator &l, const small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_traits_type::equal(l.as_base(), r.as_base());  }
 
    //!An small_vector_allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
-   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const small_vector_allocator &l, const small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
+   inline friend bool operator!=(const small_vector_allocator &l, const small_vector_allocator &r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return !(l == r);   }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -288,12 +290,12 @@ class small_vector_allocator
    typedef typename dtl::vector_for_small_vector
       <value_type, allocator_type, Options>::type                    vector_type;
 
-   BOOST_CONTAINER_FORCEINLINE bool is_internal_storage(const_pointer p) const
+   inline bool is_internal_storage(const_pointer p) const
    {  return this->internal_storage() == p;  }
 
    public:
-   BOOST_CONTAINER_FORCEINLINE const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW;
-   BOOST_CONTAINER_FORCEINLINE pointer       internal_storage()       BOOST_NOEXCEPT_OR_NOTHROW;
+   inline const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW;
+   inline pointer       internal_storage()       BOOST_NOEXCEPT_OR_NOTHROW;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
@@ -345,28 +347,28 @@ class small_vector_base
    public:
    //Make it public as it will be inherited by small_vector and container
    //must have this public member
-   typedef typename real_allocator<T, SecAlloc>::type                            secondary_allocator_t;
-   typedef typename allocator_traits<secondary_allocator_t>::
-      template portable_rebind_alloc<void>::type                                 void_allocator_t;
-   typedef typename dtl::get_small_vector_opt<Options>::type                     options_t;
+   typedef typename real_allocator<T, SecAlloc>::type                     allocator_type;
+   typedef typename allocator_traits<allocator_type>::
+      template portable_rebind_alloc<void>::type                          void_allocator_t;
+   typedef typename dtl::get_small_vector_opt<Options>::type              options_t;
    typedef typename dtl::vector_for_small_vector
-      <T, SecAlloc, Options>::type                                               base_type;
-   typedef typename allocator_traits<secondary_allocator_t>::pointer             pointer;
-   typedef typename allocator_traits<secondary_allocator_t>::const_pointer       const_pointer;
-   typedef typename allocator_traits<secondary_allocator_t>::void_pointer        void_pointer;
-   typedef typename allocator_traits<secondary_allocator_t>::const_void_pointer  const_void_pointer;
-   typedef small_vector_allocator<T, void_allocator_t, Options>                  allocator_type;
+      <T, SecAlloc, Options>::type                                        base_type;
+   typedef typename allocator_traits<allocator_type>::pointer             pointer;
+   typedef typename allocator_traits<allocator_type>::const_pointer       const_pointer;
+   typedef typename allocator_traits<allocator_type>::void_pointer        void_pointer;
+   typedef typename allocator_traits<allocator_type>::const_void_pointer  const_void_pointer;
+   typedef small_vector_allocator<T, void_allocator_t, Options>           small_allocator_type;
 
    private: 
    BOOST_COPYABLE_AND_MOVABLE(small_vector_base)
 
    friend class small_vector_allocator<T, void_allocator_t, Options>;
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->base_type::get_stored_allocator().internal_storage();   }
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
    pointer internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->base_type::get_stored_allocator().internal_storage();   }
 
@@ -378,16 +380,16 @@ class small_vector_base
 
    protected:
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
+   inline explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
       : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity)
    {}
 
    template<class AllocFwd>
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(initial_capacity_t, std::size_t capacity, BOOST_FWD_REF(AllocFwd) a)
+   inline explicit small_vector_base(initial_capacity_t, std::size_t capacity, BOOST_FWD_REF(AllocFwd) a)
       : base_type(initial_capacity_t(), this->internal_storage(), capacity, ::boost::forward<AllocFwd>(a))
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size)
+   inline explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size)
       : base_type( maybe_initial_capacity_t()
                  , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
                  , (initial_capacity >= initial_size) ? initial_capacity : initial_size
@@ -395,7 +397,7 @@ class small_vector_base
    {}
 
    template<class AllocFwd>
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size, BOOST_FWD_REF(AllocFwd) a)
+   inline explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size, BOOST_FWD_REF(AllocFwd) a)
       : base_type(maybe_initial_capacity_t()
                  , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
                  , (initial_capacity >= initial_size) ? initial_capacity : initial_size
@@ -409,20 +411,20 @@ class small_vector_base
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
-   BOOST_CONTAINER_FORCEINLINE small_vector_base& operator=(BOOST_COPY_ASSIGN_REF(small_vector_base) other)
+   inline small_vector_base& operator=(BOOST_COPY_ASSIGN_REF(small_vector_base) other)
    {  return static_cast<small_vector_base&>(this->base_type::operator=(static_cast<base_type const&>(other)));  }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector_base& operator=(BOOST_RV_REF(small_vector_base) other)
+   inline small_vector_base& operator=(BOOST_RV_REF(small_vector_base) other)
    {  return static_cast<small_vector_base&>(this->base_type::operator=(BOOST_MOVE_BASE(base_type, other))); }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(small_vector_base &other)
+   inline void swap(small_vector_base &other)
    {  return this->base_type::swap(other);  }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    protected:
-   void move_construct_impl(base_type &x, const allocator_type &a)
+   void move_construct_impl(base_type &x)
    {
-      if(base_type::is_propagable_from(x.get_stored_allocator(), x.data(), a, true)){
+      if(base_type::is_propagable_from(x.get_stored_allocator(), x.data(), this->base_type::get_stored_allocator(), true)){
          this->steal_resources(x);
       }
       else{
@@ -452,61 +454,65 @@ struct small_vector_storage_definer
    typedef small_vector_storage<T, N, final_alignment> type;
 };
 
+
+/// Figure out the offset of the first element. Idea taken from LLVM's SmallVector
 template <class T, class SecAlloc, class Options>
-struct small_vector_storage_strawman
-   : public small_vector_base<T, SecAlloc, Options>
-   , public small_vector_storage_definer<T, 1, Options>::type
+struct small_vector_storage_offset
 {
-   typedef typename small_vector_storage_definer<T, 1, Options>::type sm_storage_t;
+   typedef small_vector_base<T, SecAlloc, Options>                    base_type;
+   typedef typename small_vector_storage_definer<T, 1, Options>::type storage_type;
+   typename dtl::aligned_storage
+      < sizeof(base_type), dtl::alignment_of<base_type>::value
+      >::type base;
+
+   typename dtl::aligned_storage
+      < sizeof(storage_type), dtl::alignment_of<storage_type>::value
+      > ::type storage;
 };
 
+template <class T, class SecAlloc, class Options>
+inline std::size_t get_small_vector_storage_offset()
+{
+   typedef small_vector_storage_offset<T, SecAlloc, Options> struct_type;
+   return offsetof(struct_type, storage);
+}
+
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
 //Internal storage hack
 template<class T, class VoidAlloc, class Options>
-BOOST_CONTAINER_FORCEINLINE typename small_vector_allocator<T, VoidAlloc, Options>::const_pointer
+inline typename small_vector_allocator<T, VoidAlloc, Options>::const_pointer
    small_vector_allocator<T, VoidAlloc, Options>::internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
 {
-   typedef small_vector_storage_strawman<T, allocator_type, Options> strawman_t;
-   typedef typename strawman_t::sm_storage_t sm_storage_t;
-
-   //These warnings are false positives, as we know the alignment is correct
-   //and aligned storage is allowed to hold any type
-   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
-   #pragma GCC diagnostic push
-   #pragma GCC diagnostic ignored "-Wcast-align"
-   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-   #endif
    const vector_type& v = reinterpret_cast<const vector_type&>(*this);
-   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of<strawman_t>::value) == 0);
-   const strawman_t &straw   = static_cast<const strawman_t&>(v);
-   const sm_storage_t& stor = static_cast<const sm_storage_t&>(straw);
-   return boost::intrusive::pointer_traits<const_pointer>::pointer_to(*((const T*)stor.m_storage.data));
-   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
-   #pragma GCC diagnostic pop
-   #endif
+   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of< small_vector_storage_offset<T, allocator_type, Options> >::value) == 0);
+   const char *addr = reinterpret_cast<const char*>(&v);
+   typedef typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const char>::type const_char_pointer;
+   const_void_pointer vptr = boost::intrusive::pointer_traits<const_char_pointer>::pointer_to(*addr)
+      + get_small_vector_storage_offset<T, allocator_type, Options>();
+   return boost::intrusive::pointer_traits<const_pointer>::static_cast_from(vptr);
 }
 
 template <class T, class VoidAlloc, class Options>
-BOOST_CONTAINER_FORCEINLINE typename small_vector_allocator<T, VoidAlloc, Options>::pointer
+inline typename small_vector_allocator<T, VoidAlloc, Options>::pointer
    small_vector_allocator<T, VoidAlloc, Options>::internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
 {
-   typedef small_vector_storage_strawman<T, allocator_type, Options> strawman_t;
-   typedef typename strawman_t::sm_storage_t sm_storage_t;
-
-   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
-   #pragma GCC diagnostic push
-   #pragma GCC diagnostic ignored "-Wcast-align"
-   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
-   #endif
    vector_type& v = reinterpret_cast<vector_type&>(*this);
-   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of<strawman_t>::value) == 0);
-   strawman_t &straw   = static_cast<strawman_t&>(v);
-   sm_storage_t& stor = static_cast<sm_storage_t&>(straw);
-   return boost::intrusive::pointer_traits<pointer>::pointer_to(*((T*)stor.m_storage.data));
-   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
-   #pragma GCC diagnostic pop
-   #endif
+   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of< small_vector_storage_offset<T, allocator_type, Options> >::value) == 0);
+   char* addr = reinterpret_cast<char*>(&v);
+   typedef typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<char>::type char_pointer;
+   void_pointer vptr = boost::intrusive::pointer_traits<char_pointer>::pointer_to(*addr)
+                     + get_small_vector_storage_offset<T, allocator_type, Options>();
+   return boost::intrusive::pointer_traits<pointer>::static_cast_from(vptr);
 }
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+#pragma GCC diagnostic pop
+#endif
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -540,11 +546,11 @@ class small_vector
 
    public:
    typedef small_vector_base<T, Allocator, Options>   base_type;
-   typedef typename base_type::allocator_type   allocator_type;
-   typedef typename base_type::size_type        size_type;
-   typedef typename base_type::value_type       value_type;
+   typedef typename base_type::allocator_type         allocator_type;
+   typedef typename base_type::size_type              size_type;
+   typedef typename base_type::value_type             value_type;
 
-   BOOST_CONTAINER_FORCEINLINE static std::size_t internal_capacity()
+   inline static std::size_t internal_capacity()
    {  return static_capacity;  }
 
    typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;
@@ -555,41 +561,41 @@ class small_vector
    static const size_type static_capacity = small_vector_storage_definer<T, N, Options>::type::sms_size;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE small_vector()
+   inline small_vector()
       BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<allocator_type>::value)
       : base_type(initial_capacity_t(), internal_capacity())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector(const allocator_type &a)
+   inline explicit small_vector(const allocator_type &a)
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector(size_type n)
+   inline explicit small_vector(size_type n)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
    {  this->protected_init_n(n, value_init); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const allocator_type &a)
+   inline small_vector(size_type n, const allocator_type &a)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
    {  this->protected_init_n(n, value_init); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, default_init_t)
+   inline small_vector(size_type n, default_init_t)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
    {  this->protected_init_n(n, default_init_t()); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, default_init_t, const allocator_type &a)
+   inline small_vector(size_type n, default_init_t, const allocator_type &a)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
    {  this->protected_init_n(n, default_init_t()); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const value_type &v)
+   inline small_vector(size_type n, const value_type &v)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n)
    {  this->protected_init_n(n, v); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(size_type n, const value_type &v, const allocator_type &a)
+   inline small_vector(size_type n, const value_type &v, const allocator_type &a)
       : base_type(maybe_initial_capacity_t(), internal_capacity(), n, a)
    {  this->protected_init_n(n, v); }
 
    template <class InIt>
-   BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last
+   inline small_vector(InIt first, InIt last
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
          < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
          BOOST_MOVE_I dtl::nat >::type * = 0)
@@ -598,7 +604,7 @@ class small_vector
    {  this->assign(first, last); }
 
    template <class InIt>
-   BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last, const allocator_type& a
+   inline small_vector(InIt first, InIt last, const allocator_type& a
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
          < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
          BOOST_MOVE_I dtl::nat >::type * = 0)
@@ -606,57 +612,57 @@ class small_vector
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {  this->assign(first, last); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(const small_vector &other)
+   inline small_vector(const small_vector &other)
       : base_type( initial_capacity_t(), internal_capacity()
                  , allocator_traits_type::select_on_container_copy_construction(other.get_stored_allocator()))
    {  this->assign(other.cbegin(), other.cend());  }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(const small_vector &other, const allocator_type &a)
+   inline small_vector(const small_vector &other, const allocator_type &a)
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {  this->assign(other.cbegin(), other.cend());  }
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector(const base_type &other)
+   inline explicit small_vector(const base_type &other)
       : base_type( initial_capacity_t(), internal_capacity()
                  , allocator_traits_type::select_on_container_copy_construction(other.get_stored_allocator()))
    {  this->assign(other.cbegin(), other.cend());  }
 
-   BOOST_CONTAINER_FORCEINLINE explicit small_vector(BOOST_RV_REF(base_type) other)
+   inline explicit small_vector(BOOST_RV_REF(base_type) other)
       : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
-   {  this->move_construct_impl(other, other.get_stored_allocator());   }
+   {  this->base_type::move_construct_impl(other);   }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(BOOST_RV_REF(small_vector) other)
+   inline small_vector(BOOST_RV_REF(small_vector) other)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
       : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
-   {  this->move_construct_impl(other, other.get_stored_allocator());   }
+   {  this->base_type::move_construct_impl(other);   }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector(BOOST_RV_REF(small_vector) other, const allocator_type &a)
+   inline small_vector(BOOST_RV_REF(small_vector) other, const allocator_type &a)
       : base_type(initial_capacity_t(), internal_capacity(), a)
-   {  this->move_construct_impl(other, a);   }
+   {  this->base_type::move_construct_impl(other);   }
 
    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   BOOST_CONTAINER_FORCEINLINE small_vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
+   inline small_vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {
       this->assign(il.begin(), il.end());
    }
    #endif
 
-   BOOST_CONTAINER_FORCEINLINE small_vector& operator=(BOOST_COPY_ASSIGN_REF(small_vector) other)
+   inline small_vector& operator=(BOOST_COPY_ASSIGN_REF(small_vector) other)
    {  return static_cast<small_vector&>(this->base_type::operator=(static_cast<base_type const&>(other)));  }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector& operator=(BOOST_RV_REF(small_vector) other)
+   inline small_vector& operator=(BOOST_RV_REF(small_vector) other)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_assignable<value_type>::value
          && (allocator_traits_type::propagate_on_container_move_assignment::value
              || allocator_traits_type::is_always_equal::value))
    {  return static_cast<small_vector&>(this->base_type::operator=(BOOST_MOVE_BASE(base_type, other))); }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector& operator=(const base_type &other)
+   inline small_vector& operator=(const base_type &other)
    {  return static_cast<small_vector&>(this->base_type::operator=(other));  }
 
-   BOOST_CONTAINER_FORCEINLINE small_vector& operator=(BOOST_RV_REF(base_type) other)
+   inline small_vector& operator=(BOOST_RV_REF(base_type) other)
    {  return static_cast<small_vector&>(this->base_type::operator=(boost::move(other))); }
 
-   BOOST_CONTAINER_FORCEINLINE void swap(small_vector &other)
+   inline void swap(small_vector &other)
    {  return this->base_type::swap(other);  }
 };
 
diff --git a/contrib/restricted/boost/container/include/boost/container/vector.hpp b/contrib/restricted/boost/container/include/boost/container/vector.hpp
index d5d2f1eacb..503a80ba3d 100644
--- a/contrib/restricted/boost/container/include/boost/container/vector.hpp
+++ b/contrib/restricted/boost/container/include/boost/container/vector.hpp
@@ -120,15 +120,15 @@ class vec_iterator
                              , nat>::type                                           nonconst_iterator;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       const Pointer &get_ptr() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return   m_ptr;  }
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       Pointer &get_ptr() BOOST_NOEXCEPT_OR_NOTHROW
    {  return   m_ptr;  }
 
-   BOOST_CONTAINER_FORCEINLINE explicit vec_iterator(Pointer ptr) BOOST_NOEXCEPT_OR_NOTHROW
+   inline explicit vec_iterator(Pointer ptr) BOOST_NOEXCEPT_OR_NOTHROW
       : m_ptr(ptr)
    {}
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -136,93 +136,93 @@ class vec_iterator
    public:
 
    //Constructors
-   BOOST_CONTAINER_FORCEINLINE vec_iterator() BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator() BOOST_NOEXCEPT_OR_NOTHROW
       : m_ptr()   //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator(const vec_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator(const vec_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_ptr(other.get_ptr())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator(const nonconst_iterator &other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator(const nonconst_iterator &other) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_ptr(other.get_ptr())
    {}
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator & operator=(const vec_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator & operator=(const vec_iterator& other) BOOST_NOEXCEPT_OR_NOTHROW
    {  m_ptr = other.get_ptr();   return *this;  }
 
    //Pointer like operators
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference operator*()   const BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr);  return *m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       pointer operator->()  const BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference operator[](difference_type off) const BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr);  return m_ptr[off];  }
 
    //Increment / Decrement
-   BOOST_CONTAINER_FORCEINLINE vec_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator& operator++() BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr); ++m_ptr;  return *this; }
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator operator++(int) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr); return vec_iterator(m_ptr++); }
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator& operator--() BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr); --m_ptr; return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator operator--(int) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(!!m_ptr); return vec_iterator(m_ptr--); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE vec_iterator& operator+=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator& operator+=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(m_ptr || !off); m_ptr += off; return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE vec_iterator& operator-=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
+   inline vec_iterator& operator-=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(m_ptr || !off); m_ptr -= off; return *this;   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend vec_iterator operator+(const vec_iterator &x, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(x.m_ptr || !off); return vec_iterator(x.m_ptr+off);  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend vec_iterator operator+(difference_type off, vec_iterator right) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(right.m_ptr || !off); right.m_ptr += off;  return right; }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend vec_iterator operator-(vec_iterator left, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(left.m_ptr || !off); left.m_ptr -= off;  return left; }
 
    //Difference
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) BOOST_NOEXCEPT_OR_NOTHROW
    {  return left.m_ptr - right.m_ptr;   }
 
    //Comparison operators
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator==   (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr == r.m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=   (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr != r.m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<    (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr < r.m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<=   (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr <= r.m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>    (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr > r.m_ptr;  }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>=   (const vec_iterator& l, const vec_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
    {  return l.m_ptr >= r.m_ptr;  }
 };
@@ -233,7 +233,7 @@ struct vector_insert_ordered_cursor
    typedef typename iterator_traits<BiDirPosConstIt>::value_type  size_type;
    typedef typename iterator_traits<BiDirValueIt>::reference      reference;
 
-   BOOST_CONTAINER_FORCEINLINE vector_insert_ordered_cursor(BiDirPosConstIt posit, BiDirValueIt valueit)
+   inline vector_insert_ordered_cursor(BiDirPosConstIt posit, BiDirValueIt valueit)
       : last_position_it(posit), last_value_it(valueit)
    {}
 
@@ -247,10 +247,10 @@ struct vector_insert_ordered_cursor
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE size_type get_pos() const
+   inline size_type get_pos() const
    {  return *last_position_it;  }
 
-   BOOST_CONTAINER_FORCEINLINE reference get_val()
+   inline reference get_val()
    {  return *last_value_it;  }
 
    BiDirPosConstIt last_position_it;
@@ -258,11 +258,11 @@ struct vector_insert_ordered_cursor
 };
 
 template<class Pointer, bool IsConst>
-BOOST_CONTAINER_FORCEINLINE const Pointer &vector_iterator_get_ptr(const vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
+inline const Pointer &vector_iterator_get_ptr(const vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
 {  return   it.get_ptr();  }
 
 template<class Pointer, bool IsConst>
-BOOST_CONTAINER_FORCEINLINE Pointer &get_ptr(vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
+inline Pointer &get_ptr(vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
 {  return  it.get_ptr();  }
 
 struct initial_capacity_t {};
@@ -351,7 +351,7 @@ struct vector_alloc_holder
 
    public:
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
    {
       (void)propagate_allocator; (void)p; (void)to_alloc; (void)from_alloc;
@@ -361,7 +361,7 @@ struct vector_alloc_holder
          (propagate_allocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(from_alloc, to_alloc));
    }
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       static bool are_swap_propagable(const allocator_type &l_a, pointer l_p, const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
    {
       (void)propagate_allocator; (void)l_p; (void)r_p; (void)l_a; (void)r_a;
@@ -446,33 +446,33 @@ struct vector_alloc_holder
       holder.m_size = holder.m_capacity = 0;
    }
 
-   BOOST_CONTAINER_FORCEINLINE ~vector_alloc_holder() BOOST_NOEXCEPT_OR_NOTHROW
+   inline ~vector_alloc_holder() BOOST_NOEXCEPT_OR_NOTHROW
    {
       if(this->m_capacity){
          this->deallocate(this->m_start, this->m_capacity);
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_capacity = static_cast<stored_size_type>(c);  }
 
-   BOOST_CONTAINER_FORCEINLINE pointer allocation_command(boost::container::allocation_type command,
+   inline pointer allocation_command(boost::container::allocation_type command,
                                  size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {
       typedef typename dtl::version<allocator_type>::type alloc_version;
       return this->priv_allocation_command(alloc_version(), command, limit_size, prefer_in_recvd_out_size, reuse);
    }
 
-   BOOST_CONTAINER_FORCEINLINE pointer allocate(size_type n)
+   inline pointer allocate(size_type n)
    {
       const size_type max_alloc = allocator_traits_type::max_size(this->alloc());
       const size_type max = max_alloc <= stored_size_type(-1) ? max_alloc : stored_size_type(-1);
@@ -482,7 +482,7 @@ struct vector_alloc_holder
       return allocator_traits_type::allocate(this->alloc(), n);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void deallocate(const pointer &p, size_type n)
+   inline void deallocate(const pointer &p, size_type n)
    {
       allocator_traits_type::deallocate(this->alloc(), p, n);
    }
@@ -539,22 +539,22 @@ struct vector_alloc_holder
       x.m_size = x.m_capacity = 0;
    }
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
+   inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE const pointer   &start() const     BOOST_NOEXCEPT_OR_NOTHROW
+   inline const pointer   &start() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_start;  }
-   BOOST_CONTAINER_FORCEINLINE       size_type capacity() const     BOOST_NOEXCEPT_OR_NOTHROW
+   inline       size_type capacity() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_capacity;  }
-   BOOST_CONTAINER_FORCEINLINE void start(const pointer &p)       BOOST_NOEXCEPT_OR_NOTHROW
+   inline void start(const pointer &p)       BOOST_NOEXCEPT_OR_NOTHROW
       {  m_start = p;  }
-   BOOST_CONTAINER_FORCEINLINE void capacity(const size_type &c)  BOOST_NOEXCEPT_OR_NOTHROW
+   inline void capacity(const size_type &c)  BOOST_NOEXCEPT_OR_NOTHROW
       {  BOOST_ASSERT( c <= stored_size_type(-1)); this->set_stored_capacity(c);  }
 
-   static BOOST_CONTAINER_FORCEINLINE void on_capacity_overflow()
+   static inline void on_capacity_overflow()
    { }
 
    private:
@@ -680,26 +680,26 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
          (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), n, boost::movelib::to_raw_pointer(this->start()));
    }
 
-   static BOOST_CONTAINER_FORCEINLINE void on_capacity_overflow()
+   static inline void on_capacity_overflow()
    {  allocator_type::on_capacity_overflow();  }
 
-   BOOST_CONTAINER_FORCEINLINE void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_first_allocation(size_type cap)
+   inline void priv_first_allocation(size_type cap)
    {
       if(cap > allocator_type::internal_capacity){
          on_capacity_overflow();
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE void deep_swap(vector_alloc_holder &x)
+   inline void deep_swap(vector_alloc_holder &x)
       {  this->priv_deep_swap(x);   }
 
    template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
@@ -712,29 +712,29 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
       this->priv_deep_swap(x);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void swap_resources(vector_alloc_holder &) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void swap_resources(vector_alloc_holder &) BOOST_NOEXCEPT_OR_NOTHROW
    {  //Containers with version 0 allocators can't be moved without moving elements one by one
       on_capacity_overflow();
    }
 
-   BOOST_CONTAINER_FORCEINLINE void steal_resources(vector_alloc_holder &)
+   inline void steal_resources(vector_alloc_holder &)
    {  //Containers with version 0 allocators can't be moved without moving elements one by one
       on_capacity_overflow();
    }
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
+   inline allocator_type &alloc() BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   BOOST_CONTAINER_FORCEINLINE bool try_expand_fwd(size_type at_least)
+   inline bool try_expand_fwd(size_type at_least)
    {  return !at_least;  }
 
-   BOOST_CONTAINER_FORCEINLINE pointer start() const       BOOST_NOEXCEPT_OR_NOTHROW
+   inline pointer start() const       BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_type::internal_storage();  }
    
-   BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   inline size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_type::internal_capacity;  }
    
    stored_size_type m_size;
@@ -822,7 +822,7 @@ private:
    typedef value_less<T>                                                      value_less_t;
 
    //If provided the stored_size option must specify a type that is equal or a type that is smaller.
-   BOOST_STATIC_ASSERT( (sizeof(stored_size_type) < sizeof(alloc_size_type) ||
+   BOOST_CONTAINER_STATIC_ASSERT( (sizeof(stored_size_type) < sizeof(alloc_size_type) ||
                         dtl::is_same<stored_size_type, alloc_size_type>::value) );
 
    typedef typename dtl::version<allocator_type>::type alloc_version;
@@ -837,11 +837,11 @@ private:
 
 
    protected:
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
    {  return alloc_holder_t::is_propagable_from(from_alloc, p, to_alloc, propagate_allocator);  }
 
-   BOOST_CONTAINER_FORCEINLINE
+   inline
       static bool are_swap_propagable( const allocator_type &l_a, pointer l_p
                                      , const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
    {  return alloc_holder_t::are_swap_propagable(l_a, l_p, r_a, r_p, propagate_allocator);  }
@@ -855,23 +855,23 @@ private:
 
    protected:
 
-   BOOST_CONTAINER_FORCEINLINE void steal_resources(vector &x)
+   inline void steal_resources(vector &x)
    {  return this->m_holder.steal_resources(x.m_holder);   }
 
-   BOOST_CONTAINER_FORCEINLINE void protected_set_size(size_type n)
+   inline void protected_set_size(size_type n)
    {  this->m_holder.m_size = static_cast<stored_size_type>(n);   }
 
    template<class AllocFwd>
-   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type cap, BOOST_FWD_REF(AllocFwd) a)
+   inline vector(initial_capacity_t, pointer initial_memory, size_type cap, BOOST_FWD_REF(AllocFwd) a)
       : m_holder(initial_capacity_t(), initial_memory, cap, ::boost::forward<AllocFwd>(a))
    {}
 
-   BOOST_CONTAINER_FORCEINLINE vector(initial_capacity_t, pointer initial_memory, size_type cap)
+   inline vector(initial_capacity_t, pointer initial_memory, size_type cap)
       : m_holder(initial_capacity_t(), initial_memory, cap)
    {}
 
    template<class SizeType, class AllocFwd>
-   BOOST_CONTAINER_FORCEINLINE vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity, BOOST_FWD_REF(AllocFwd) a)
+   inline vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity, BOOST_FWD_REF(AllocFwd) a)
       : m_holder(maybe_initial_capacity_t(), p, initial_capacity, ::boost::forward<AllocFwd>(a))
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -880,7 +880,7 @@ private:
    }
 
    template<class SizeType>
-   BOOST_CONTAINER_FORCEINLINE vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity)
+   inline vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity)
       : m_holder(maybe_initial_capacity_t(), p, initial_capacity)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -1094,7 +1094,7 @@ private:
    //! <b>Complexity</b>: Constant.
    vector(BOOST_RV_REF(vector) x) BOOST_NOEXCEPT_OR_NOTHROW
       :  m_holder(boost::move(x.m_holder))
-   {  BOOST_STATIC_ASSERT((!allocator_traits_type::is_partially_propagable::value));  }
+   {  BOOST_CONTAINER_STATIC_ASSERT((!allocator_traits_type::is_partially_propagable::value));  }
 
    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Constructs a vector that will use a copy of allocator a
@@ -1202,7 +1202,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws or T's copy/move constructor/assignment throws.
    //!
    //! <b>Complexity</b>: Linear to the number of elements in x.
-   BOOST_CONTAINER_FORCEINLINE vector& operator=(BOOST_COPY_ASSIGN_REF(vector) x)
+   inline vector& operator=(BOOST_COPY_ASSIGN_REF(vector) x)
    {
       if (BOOST_LIKELY(&x != this)){
          this->priv_copy_assign(x);
@@ -1214,7 +1214,7 @@ private:
    //! <b>Effects</b>: Make *this container contains elements from il.
    //!
    //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()).
-   BOOST_CONTAINER_FORCEINLINE vector& operator=(std::initializer_list<value_type> il)
+   inline vector& operator=(std::initializer_list<value_type> il)
    {
       this->assign(il.begin(), il.end());
       return *this;
@@ -1232,7 +1232,7 @@ private:
    //! <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 vector& operator=(BOOST_RV_REF(vector) x)
+   inline vector& operator=(BOOST_RV_REF(vector) x)
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
                         || allocator_traits_type::is_always_equal::value)
    {
@@ -1255,7 +1255,7 @@ private:
    //!
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherA>
-   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
+   inline typename dtl::enable_if_and
                            < vector&
                            , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
                            , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
@@ -1277,7 +1277,7 @@ private:
    //!
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherA>
-   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
+   inline typename dtl::enable_if_and
                            < vector&
                            , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
                            , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
@@ -1334,7 +1334,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws or
    //!   T's constructor from dereferencing iniializer_list iterator throws.
    //!
-   BOOST_CONTAINER_FORCEINLINE void assign(std::initializer_list<T> il)
+   inline void assign(std::initializer_list<T> il)
    {
       this->assign(il.begin(), il.end());
    }
@@ -1405,7 +1405,7 @@ private:
    //!   T's copy/move constructor/assignment throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const value_type& val)
+   inline void assign(size_type n, const value_type& val)
    {  this->assign(cvalue_iterator(val, n), cvalue_iterator());   }
 
    //! <b>Effects</b>: Returns a copy of the internal allocator.
@@ -1413,7 +1413,7 @@ private:
    //! <b>Throws</b>: If allocator's copy constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->m_holder.alloc();  }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
@@ -1423,7 +1423,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline 
       stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_holder.alloc(); }
 
@@ -1434,7 +1434,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return this->m_holder.alloc(); }
 
@@ -1449,7 +1449,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
    { return iterator(this->m_holder.start()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
@@ -1457,7 +1457,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
    { return const_iterator(this->m_holder.start()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the vector.
@@ -1465,7 +1465,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline iterator end() BOOST_NOEXCEPT_OR_NOTHROW
    {
       iterator it (this->m_holder.start());
       it += difference_type(this->m_holder.m_size);
@@ -1477,7 +1477,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->cend(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@@ -1486,7 +1486,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
    { return reverse_iterator(this->end());      }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -1495,7 +1495,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->crbegin(); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@@ -1504,7 +1504,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
    { return reverse_iterator(this->begin());       }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -1513,7 +1513,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the vector.
@@ -1521,7 +1521,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
    { return const_iterator(this->m_holder.start()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the vector.
@@ -1529,7 +1529,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const_iterator it (this->m_holder.start());
       it += difference_type(this->m_holder.m_size);
@@ -1542,7 +1542,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
    { return const_reverse_iterator(this->end());}
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -1551,7 +1551,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
    { return const_reverse_iterator(this->begin()); }
 
    //////////////////////////////////////////////
@@ -1565,7 +1565,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
    { return !this->m_holder.m_size; }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the vector.
@@ -1573,7 +1573,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->m_holder.m_size; }
 
    //! <b>Effects</b>: Returns the largest possible size of the vector.
@@ -1581,7 +1581,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
    { return allocator_traits_type::max_size(this->m_holder.alloc()); }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1590,7 +1590,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws, or T's copy/move or value initialization throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   BOOST_CONTAINER_FORCEINLINE void resize(size_type new_size)
+   inline void resize(size_type new_size)
    {  this->priv_resize(new_size, value_init, alloc_version());  }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1601,7 +1601,7 @@ private:
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_FORCEINLINE void resize(size_type new_size, default_init_t)
+   inline void resize(size_type new_size, default_init_t)
    {  this->priv_resize(new_size, default_init, alloc_version());  }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1610,7 +1610,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws, or T's copy/move constructor throws.
    //!
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
-   BOOST_CONTAINER_FORCEINLINE void resize(size_type new_size, const T& x)
+   inline void resize(size_type new_size, const T& x)
    {  this->priv_resize(new_size, x, alloc_version());  }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -1619,7 +1619,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->m_holder.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -1628,7 +1628,7 @@ private:
    //!   n; otherwise, capacity() is unchanged. In either case, size() is unchanged.
    //!
    //! <b>Throws</b>: If memory allocation allocation throws or T's copy/move constructor throws.
-   BOOST_CONTAINER_FORCEINLINE void reserve(size_type new_cap)
+   inline void reserve(size_type new_cap)
    {
       if (this->capacity() < new_cap){
          this->priv_move_to_new_buffer(new_cap, alloc_version());
@@ -1641,7 +1641,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws, or T's copy/move constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
+   inline void shrink_to_fit()
    {  this->priv_shrink_to_fit(alloc_version());   }
 
    //////////////////////////////////////////////
@@ -1658,7 +1658,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference front() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference front() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
       return *this->m_holder.start();
@@ -1672,7 +1672,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference front() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
       return *this->m_holder.start();
@@ -1686,7 +1686,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference back() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
       return this->m_holder.start()[difference_type(this->m_holder.m_size - 1u)];
@@ -1700,7 +1700,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reference back()  const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference back()  const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
       return this->m_holder.start()[this->m_holder.m_size - 1];
@@ -1714,7 +1714,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size > n);
       return this->m_holder.start()[difference_type(n)];
@@ -1728,7 +1728,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size > n);
@@ -1746,7 +1746,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
@@ -1764,7 +1764,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
@@ -1781,7 +1781,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       //Range check assert done in priv_index_of
@@ -1798,7 +1798,7 @@ private:
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       //Range check assert done in priv_index_of
@@ -1813,7 +1813,7 @@ private:
    //! <b>Throws</b>: range_error if n >= size()
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference at(size_type n)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline reference at(size_type n)
    {
       this->priv_throw_if_out_of_range(n);
       return this->m_holder.start()[difference_type(n)];
@@ -1827,7 +1827,7 @@ private:
    //! <b>Throws</b>: range_error if n >= size()
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_reference at(size_type n) const
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const_reference at(size_type n) const
    {
       this->priv_throw_if_out_of_range(n);
       return this->m_holder.start()[n];
@@ -1845,7 +1845,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE T* data() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline T* data() BOOST_NOEXCEPT_OR_NOTHROW
    { return this->priv_raw_begin(); }
 
    //! <b>Returns</b>: A pointer such that [data(),data() + size()) is a valid range.
@@ -1854,7 +1854,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const T * data()  const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline const T * data()  const BOOST_NOEXCEPT_OR_NOTHROW
    { return this->priv_raw_begin(); }
 
    //////////////////////////////////////////////
@@ -1874,7 +1874,7 @@ private:
    //!
    //! <b>Complexity</b>: Amortized constant time.
    template<class ...Args>
-   BOOST_CONTAINER_FORCEINLINE reference emplace_back(BOOST_FWD_REF(Args)...args)
+   inline reference emplace_back(BOOST_FWD_REF(Args)...args)
    {
       T* const p = this->priv_raw_end();
       if (BOOST_LIKELY(this->room_enough())){
@@ -1899,7 +1899,7 @@ private:
    //!
    //! <b>Note</b>: Non-standard extension.
    template<class ...Args>
-   BOOST_CONTAINER_FORCEINLINE bool stable_emplace_back(BOOST_FWD_REF(Args)...args)
+   inline bool stable_emplace_back(BOOST_FWD_REF(Args)...args)
    {
       const bool is_room_enough = this->room_enough() || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(1u));
       if (BOOST_LIKELY(is_room_enough)){
@@ -1921,7 +1921,7 @@ private:
    //! <b>Complexity</b>: If position is end(), amortized constant time
    //!   Linear time otherwise.
    template<class ...Args>
-   BOOST_CONTAINER_FORCEINLINE iterator emplace(const_iterator position, BOOST_FWD_REF(Args) ...args)
+   inline iterator emplace(const_iterator position, BOOST_FWD_REF(Args) ...args)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(position));
       //Just call more general insert(pos, size, value) and return iterator
@@ -1934,7 +1934,7 @@ private:
 
    #define BOOST_CONTAINER_VECTOR_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE reference emplace_back(BOOST_MOVE_UREF##N)\
+   inline reference emplace_back(BOOST_MOVE_UREF##N)\
    {\
       T* const p = this->priv_raw_end();\
       if (BOOST_LIKELY(this->room_enough())){\
@@ -1951,7 +1951,7 @@ private:
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE bool stable_emplace_back(BOOST_MOVE_UREF##N)\
+   inline bool stable_emplace_back(BOOST_MOVE_UREF##N)\
    {\
       const bool is_room_enough = this->room_enough() || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(1u));\
       if (BOOST_LIKELY(is_room_enough)){\
@@ -1963,7 +1963,7 @@ private:
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE iterator emplace(const_iterator pos BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   inline iterator emplace(const_iterator pos BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       BOOST_ASSERT(this->priv_in_range_or_end(pos));\
       typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
@@ -2029,7 +2029,7 @@ private:
    //! <b>Throws</b>: If memory allocation throws or T's copy/move constructor throws.
    //!
    //! <b>Complexity</b>: Linear to n.
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, size_type n, const T& x)
+   inline iterator insert(const_iterator p, size_type n, const T& x)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       dtl::insert_n_copies_proxy<allocator_type> proxy(x);
@@ -2069,7 +2069,7 @@ private:
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator pos, FwdIt first, FwdIt last
+   inline iterator insert(const_iterator pos, FwdIt first, FwdIt last
       , typename dtl::disable_if_or
          < void
          , dtl::is_convertible<FwdIt, size_type>
@@ -2106,7 +2106,7 @@ private:
    //!   a non-standard extension.
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class InIt>
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator pos, size_type num, InIt first, InIt last)
+   inline iterator insert(const_iterator pos, size_type num, InIt first, InIt last)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
       BOOST_ASSERT(dtl::is_input_iterator<InIt>::value ||
@@ -2125,7 +2125,7 @@ private:
    //! <b>Returns</b>: an iterator to the first inserted element or position if first == last.
    //!
    //! <b>Complexity</b>: Linear to the range [il.begin(), il.end()).
-   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator position, std::initializer_list<value_type> il)
+   inline iterator insert(const_iterator position, std::initializer_list<value_type> il)
    {
       //Assertion done in insert()
       return this->insert(position, il.begin(), il.end());
@@ -2137,7 +2137,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant time.
-   BOOST_CONTAINER_FORCEINLINE void pop_back() BOOST_NOEXCEPT_OR_NOTHROW
+   inline void pop_back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
       //Destroy last element
@@ -2199,7 +2199,7 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE void swap(vector& x)
+   inline void swap(vector& x)
       BOOST_NOEXCEPT_IF( ((allocator_traits_type::propagate_on_container_swap::value
                                     || allocator_traits_type::is_always_equal::value) &&
                                     !dtl::is_version<allocator_type, 0>::value))
@@ -2217,7 +2217,7 @@ private:
    //!
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherA>
-   BOOST_CONTAINER_FORCEINLINE void swap(vector<T, OtherA, Options> & x
+   inline void swap(vector<T, OtherA, Options> & x
             , typename dtl::enable_if_and
                      < void
                      , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
@@ -2233,19 +2233,19 @@ private:
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   inline void clear() BOOST_NOEXCEPT_OR_NOTHROW
    {  this->priv_destroy_all();  }
 
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE friend bool operator==(const vector& x, const vector& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator==(const vector& x, const vector& 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.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const vector& x, const vector& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator!=(const vector& x, const vector& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
@@ -2257,25 +2257,25 @@ private:
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE friend bool operator>(const vector& x, const vector& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator>(const vector& x, const vector& 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.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const vector& x, const vector& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator<=(const vector& x, const vector& 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.
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const vector& x, const vector& y)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline friend bool operator>=(const vector& x, const vector& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE friend void swap(vector& x, vector& y)
+   inline friend void swap(vector& x, vector& y)
        BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
    {  x.swap(y);  }
 
@@ -2297,18 +2297,18 @@ private:
 
    //Absolutely experimental. This function might change, disappear or simply crash!
    template<class BiDirPosConstIt, class BiDirValueIt>
-   BOOST_CONTAINER_FORCEINLINE void insert_ordered_at(const size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
+   inline void insert_ordered_at(const size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
    {
       typedef vector_insert_ordered_cursor<BiDirPosConstIt, BiDirValueIt> inserter_t;
       return this->priv_insert_ordered_at(element_count, inserter_t(last_position_it, last_value_it));
    }
 
    template<class InputIt>
-   BOOST_CONTAINER_FORCEINLINE void merge(InputIt first, InputIt last)
+   inline void merge(InputIt first, InputIt last)
    {  this->merge(first, last, value_less_t());  }
 
    template<class InputIt, class Compare>
-   BOOST_CONTAINER_FORCEINLINE void merge(InputIt first, InputIt last, Compare comp)
+   inline void merge(InputIt first, InputIt last, Compare comp)
    {
       size_type const s = this->size();
       size_type const c = this->capacity();
@@ -2329,11 +2329,11 @@ private:
    }
 
    template<class InputIt>
-   BOOST_CONTAINER_FORCEINLINE void merge_unique(InputIt first, InputIt last)
+   inline void merge_unique(InputIt first, InputIt last)
    {  this->merge_unique(first, last, value_less_t());  }
 
    template<class InputIt, class Compare>
-   BOOST_CONTAINER_FORCEINLINE void merge_unique(InputIt first, InputIt last, Compare comp)
+   inline void merge_unique(InputIt first, InputIt last, Compare comp)
    {
       size_type const old_size = this->size();
       this->priv_set_difference_back(first, last, comp);
@@ -2436,7 +2436,7 @@ private:
    }
 
    template<class FwdIt, class Compare>
-   BOOST_CONTAINER_FORCEINLINE void priv_merge_in_new_buffer(FwdIt, size_type, Compare, version_0)
+   inline void priv_merge_in_new_buffer(FwdIt, size_type, Compare, version_0)
    {
       alloc_holder_t::on_capacity_overflow();
    }
@@ -2498,13 +2498,13 @@ private:
       new_values_destroyer.release();
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool room_enough() const
+   inline bool room_enough() const
    {  return this->m_holder.m_size != this->m_holder.capacity();   }
 
-   BOOST_CONTAINER_FORCEINLINE pointer back_ptr() const
+   inline pointer back_ptr() const
    {  return this->m_holder.start() + difference_type(this->m_holder.m_size);  }
 
-   BOOST_CONTAINER_FORCEINLINE size_type priv_index_of(pointer p) const
+   inline size_type priv_index_of(pointer p) const
    {
       BOOST_ASSERT(this->m_holder.start() <= p);
       BOOST_ASSERT(p <= (this->m_holder.start()+difference_type(this->size())));
@@ -2607,7 +2607,7 @@ private:
    }
 
    template<class Vector>  //Template it to avoid it in explicit instantiations
-   BOOST_CONTAINER_FORCEINLINE void priv_swap(Vector &x, dtl::true_type)   //version_0
+   inline void priv_swap(Vector &x, dtl::true_type)   //version_0
    {  this->m_holder.deep_swap(x.m_holder);  }
 
    template<class Vector>  //Template it to avoid it in explicit instantiations
@@ -2653,16 +2653,16 @@ private:
       dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
    }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_move_to_new_buffer(size_type, version_0)
+   inline void priv_move_to_new_buffer(size_type, version_0)
    {  alloc_holder_t::on_capacity_overflow();  }
 
-   BOOST_CONTAINER_FORCEINLINE dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> > priv_dummy_empty_proxy()
+   inline dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> > priv_dummy_empty_proxy()
    {
       return dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> >
          (::boost::make_move_iterator((T *)0));
    }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_move_to_new_buffer(size_type new_cap, version_1)
+   inline void priv_move_to_new_buffer(size_type new_cap, version_1)
    {
       //There is not enough memory, allocate a new buffer
       //Pass the hint so that allocators can take advantage of this.
@@ -2735,34 +2735,34 @@ private:
    }
 
    template<class U>
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const const_iterator &p, BOOST_FWD_REF(U) u)
+   inline iterator priv_insert(const const_iterator &p, BOOST_FWD_REF(U) u)
    {
       return this->emplace(p, ::boost::forward<U>(u));
    }
 
    template <class U>
-   BOOST_CONTAINER_FORCEINLINE void priv_push_back(BOOST_FWD_REF(U) u)
+   inline void priv_push_back(BOOST_FWD_REF(U) u)
    {
       this->emplace_back(::boost::forward<U>(u));
    }
 
    //Overload to support compiler errors that instantiate too much
-   BOOST_CONTAINER_FORCEINLINE void priv_push_back(::boost::move_detail::nat)
+   inline void priv_push_back(::boost::move_detail::nat)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator, ::boost::move_detail::nat)
+   inline iterator priv_insert(const_iterator, ::boost::move_detail::nat)
    {  return iterator();  }
 
-   BOOST_CONTAINER_FORCEINLINE dtl::insert_n_copies_proxy<allocator_type> priv_resize_proxy(const T &x)
+   inline dtl::insert_n_copies_proxy<allocator_type> priv_resize_proxy(const T &x)
    {  return dtl::insert_n_copies_proxy<allocator_type>(x);   }
 
-   BOOST_CONTAINER_FORCEINLINE dtl::insert_default_initialized_n_proxy<allocator_type> priv_resize_proxy(default_init_t)
+   inline dtl::insert_default_initialized_n_proxy<allocator_type> priv_resize_proxy(default_init_t)
    {  return dtl::insert_default_initialized_n_proxy<allocator_type>();  }
 
-   BOOST_CONTAINER_FORCEINLINE dtl::insert_value_initialized_n_proxy<allocator_type> priv_resize_proxy(value_init_t)
+   inline dtl::insert_value_initialized_n_proxy<allocator_type> priv_resize_proxy(value_init_t)
    {  return dtl::insert_value_initialized_n_proxy<allocator_type>(); }
 
-   BOOST_CONTAINER_FORCEINLINE void priv_shrink_to_fit(version_0) BOOST_NOEXCEPT_OR_NOTHROW
+   inline void priv_shrink_to_fit(version_0) BOOST_NOEXCEPT_OR_NOTHROW
    {}
 
    void priv_shrink_to_fit(version_1)
@@ -2808,7 +2808,7 @@ private:
    }
 
    template <class InsertionProxy>
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert_forward_range_no_capacity
+   inline iterator priv_insert_forward_range_no_capacity
       (T * const, const size_type, const InsertionProxy , version_0)
    {
       return alloc_holder_t::on_capacity_overflow(), iterator();
@@ -2879,7 +2879,7 @@ private:
    }
 
    template <class InsertionProxy>
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert_forward_range
+   inline iterator priv_insert_forward_range
       (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy)
    {
       BOOST_ASSERT(this->m_holder.capacity() >= this->m_holder.m_size);
@@ -3017,14 +3017,14 @@ private:
    }
 
    private:
-   BOOST_CONTAINER_FORCEINLINE T *priv_raw_begin() const
+   inline T *priv_raw_begin() const
    {  return boost::movelib::to_raw_pointer(m_holder.start());  }
 
-   BOOST_CONTAINER_FORCEINLINE T* priv_raw_end() const
+   inline T* priv_raw_end() const
    {  return this->priv_raw_begin() + this->m_holder.m_size;  }
 
    template <class InsertionProxy>  //inline single-element version as it is significantly smaller
-   BOOST_CONTAINER_FORCEINLINE void priv_insert_forward_range_expand_forward
+   inline void priv_insert_forward_range_expand_forward
       (T* const raw_pos, const size_type, InsertionProxy insert_range_proxy, dtl::true_type)
    {
       BOOST_ASSERT(this->room_enough());
@@ -3051,7 +3051,7 @@ private:
    }
 
    template <class InsertionProxy>
-   BOOST_CONTAINER_FORCEINLINE void priv_insert_forward_range_expand_forward
+   inline void priv_insert_forward_range_expand_forward
       (T* const raw_pos, const size_type n, InsertionProxy insert_range_proxy, dtl::false_type)
    {
       //There is enough memory
@@ -3113,12 +3113,12 @@ private:
       }
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_in_range(const_iterator pos) const
+   inline bool priv_in_range(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos < this->end());
    }
 
-   BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
+   inline bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
    }
diff --git a/contrib/restricted/boost/container/src/dlmalloc_2_8_6.c b/contrib/restricted/boost/container/src/dlmalloc_2_8_6.c
index 3424f59b17..63ef0d3fb8 100644
--- a/contrib/restricted/boost/container/src/dlmalloc_2_8_6.c
+++ b/contrib/restricted/boost/container/src/dlmalloc_2_8_6.c
@@ -4013,6 +4013,7 @@ static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {
       break;
   }
   assert(nfences >= 2);
+  (void) nfences; //Added by iG to silence warning about unused nfences
 
   /* Insert the rest of old top into a bin as an ordinary free chunk */
   if (csp != old_top) {
diff --git a/contrib/restricted/boost/container/src/dlmalloc_ext_2_8_6.c b/contrib/restricted/boost/container/src/dlmalloc_ext_2_8_6.c
index 2bdd3afdf7..778dd88247 100644
--- a/contrib/restricted/boost/container/src/dlmalloc_ext_2_8_6.c
+++ b/contrib/restricted/boost/container/src/dlmalloc_ext_2_8_6.c
@@ -1224,14 +1224,12 @@ size_t boost_cont_allocated_memory()
       if (is_initialized(m)) {
       size_t nfree = SIZE_T_ONE; /* top always free */
       size_t mfree = m->topsize + TOP_FOOT_SIZE;
-      size_t sum = mfree;
       msegmentptr s = &m->seg;
       while (s != 0) {
          mchunkptr q = align_as_chunk(s->base);
          while (segment_holds(s, q) &&
                q != m->top && q->head != FENCEPOST_HEAD) {
             size_t sz = chunksize(q);
-            sum += sz;
             if (!is_inuse(q)) {
             mfree += sz;
             ++nfree;
diff --git a/contrib/restricted/boost/container/src/pool_resource.cpp b/contrib/restricted/boost/container/src/pool_resource.cpp
index 631c9d8f4c..512f414a76 100644
--- a/contrib/restricted/boost/container/src/pool_resource.cpp
+++ b/contrib/restricted/boost/container/src/pool_resource.cpp
@@ -20,7 +20,6 @@
 #include <boost/container/detail/placement_new.hpp>
 #include <boost/intrusive/linear_slist_algorithms.hpp>
 #include <boost/intrusive/detail/math.hpp>
-#include <boost/static_assert.hpp>
 
 #include <cstddef>
 
@@ -96,10 +95,10 @@ class pool_data_t
 //pool_resource
 
 //Detect overflow in ceil_pow2
-BOOST_STATIC_ASSERT(pool_options_default_max_blocks_per_chunk <= (std::size_t(-1)/2u+1u));
+BOOST_CONTAINER_STATIC_ASSERT(pool_options_default_max_blocks_per_chunk <= (std::size_t(-1)/2u+1u));
 //Sanity checks
-BOOST_STATIC_ASSERT(bi::detail::static_is_pow2<pool_options_default_max_blocks_per_chunk>::value);
-BOOST_STATIC_ASSERT(bi::detail::static_is_pow2<pool_options_minimum_largest_required_pool_block>::value);
+BOOST_CONTAINER_STATIC_ASSERT(bi::detail::static_is_pow2<pool_options_default_max_blocks_per_chunk>::value);
+BOOST_CONTAINER_STATIC_ASSERT(bi::detail::static_is_pow2<pool_options_minimum_largest_required_pool_block>::value);
 
 //unsynchronized_pool_resource
 
diff --git a/contrib/restricted/boost/container/ya.make b/contrib/restricted/boost/container/ya.make
index b2617bbe88..37dd4b3f04 100644
--- a/contrib/restricted/boost/container/ya.make
+++ b/contrib/restricted/boost/container/ya.make
@@ -9,9 +9,9 @@ LICENSE(
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.84.0)
+VERSION(1.85.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/container/archive/boost-1.84.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/container/archive/boost-1.85.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/assert