Update contrib/restricted/boost/intrusive to 1.85.0

d0bc972b8d03404c917d9653386f945a43392d56

36 files changed, 534 insertions, 526 deletions

diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp
index 747d41cc38..4eda39e699 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree.hpp
@@ -18,7 +18,6 @@
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
 #include <boost/intrusive/detail/minimal_pair_header.hpp>
 
-#include <boost/static_assert.hpp>
 #include <boost/intrusive/avl_set_hook.hpp>
 #include <boost/intrusive/detail/avltree_node.hpp>
 #include <boost/intrusive/bstree.hpp>
@@ -533,48 +532,48 @@ class avltree
    typedef typename Base::const_reverse_iterator     const_reverse_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE avltree()
+   inline avltree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit avltree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE avltree( bool unique, Iterator b, Iterator e
+   inline avltree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE avltree(BOOST_RV_REF(avltree) x)
+   inline avltree(BOOST_RV_REF(avltree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE avltree& operator=(BOOST_RV_REF(avltree) x)
+   inline avltree& operator=(BOOST_RV_REF(avltree) x)
    {  return static_cast<avltree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const avltree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(avltree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static avltree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const avltree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const avltree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static avltree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<avltree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const avltree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const avltree &>(Base::container_from_iterator(it));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp
index 0fd158d595..8195490650 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/avltree_algorithms.hpp
@@ -42,7 +42,7 @@ struct avltree_node_cloner
    typedef typename NodeTraits::node_ptr  node_ptr;
    typedef detail::ebo_functor_holder<F>  base_t;
 
-   BOOST_INTRUSIVE_FORCEINLINE avltree_node_cloner(F f)
+   inline avltree_node_cloner(F f)
       :  base_t(f)
    {}
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp
index 51687ebd27..8196d36b3f 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree.hpp
@@ -16,7 +16,6 @@
 #include <boost/intrusive/intrusive_fwd.hpp>
 
 #include <boost/intrusive/detail/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/bs_set_hook.hpp>
 #include <boost/intrusive/detail/tree_node.hpp>
@@ -105,7 +104,7 @@ struct bstbase3
 
    struct holder_t : public ValueTraits
    {
-      BOOST_INTRUSIVE_FORCEINLINE explicit holder_t(const ValueTraits &vtraits)
+      inline explicit holder_t(const ValueTraits &vtraits)
          : ValueTraits(vtraits)
       {}
       header_holder_type root;
@@ -113,7 +112,7 @@ struct bstbase3
 
    static bstbase3 &get_tree_base_from_end_iterator(const const_iterator &end_iterator)
    {
-      BOOST_STATIC_ASSERT(has_container_from_iterator);
+      BOOST_INTRUSIVE_STATIC_ASSERT(has_container_from_iterator);
       node_ptr p = end_iterator.pointed_node();
       header_holder_type* h = header_holder_type::get_holder(p);
       holder_t *holder = get_parent_from_member<holder_t, header_holder_type>(h, &holder_t::root);
@@ -121,73 +120,73 @@ struct bstbase3
       return *base;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE bstbase3(const ValueTraits &vtraits)
+   inline bstbase3(const ValueTraits &vtraits)
       : holder(vtraits)
    {
       node_algorithms::init_header(this->header_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr header_ptr()
+   inline node_ptr header_ptr()
    { return holder.root.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr header_ptr() const
+   inline const_node_ptr header_ptr() const
    { return holder.root.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &get_value_traits() const
+   inline const value_traits &get_value_traits() const
    {  return this->holder;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE value_traits &get_value_traits()
+   inline value_traits &get_value_traits()
    {  return this->holder;  }
 
    typedef typename boost::intrusive::value_traits_pointers
       <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const
+   inline const_value_traits_ptr priv_value_traits_ptr() const
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->get_value_traits());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT
+   inline iterator begin() BOOST_NOEXCEPT
    {  return iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT
+   inline const_iterator begin() const BOOST_NOEXCEPT
    {  return cbegin();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT
+   inline const_iterator cbegin() const BOOST_NOEXCEPT
    {  return const_iterator(node_algorithms::begin_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT
+   inline iterator end() BOOST_NOEXCEPT
    {  return iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT
+   inline const_iterator end() const BOOST_NOEXCEPT
    {  return cend();  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT
+   inline const_iterator cend() const BOOST_NOEXCEPT
    {  return const_iterator(node_algorithms::end_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE iterator root()
+   inline iterator root()
    {  return iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator root() const
+   inline const_iterator root() const
    {  return croot();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator croot() const
+   inline const_iterator croot() const
    {  return const_iterator(node_algorithms::root_node(this->header_ptr()), this->priv_value_traits_ptr());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin()
+   inline reverse_iterator rbegin()
    {  return reverse_iterator(end());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const
+   inline const_reverse_iterator rbegin() const
    {  return const_reverse_iterator(end());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const
+   inline const_reverse_iterator crbegin() const
    {  return const_reverse_iterator(end());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend()
+   inline reverse_iterator rend()
    {  return reverse_iterator(begin());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const
+   inline const_reverse_iterator rend() const
    {  return const_reverse_iterator(begin());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const
+   inline const_reverse_iterator crend() const
    {  return const_reverse_iterator(begin());   }
 
    void replace_node(iterator replace_this, reference with_this)
@@ -199,7 +198,7 @@ struct bstbase3
          node_algorithms::init(replace_this.pointed_node());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void rebalance() BOOST_NOEXCEPT
+   inline void rebalance() BOOST_NOEXCEPT
    {  node_algorithms::rebalance(this->header_ptr()); }
 
    iterator rebalance_subtree(iterator r) BOOST_NOEXCEPT
@@ -207,13 +206,13 @@ struct bstbase3
 
    static iterator s_iterator_to(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
 
    static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       return const_iterator (value_traits::to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), const_value_traits_ptr());
    }
 
@@ -223,7 +222,7 @@ struct bstbase3
    const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT
    {  return const_iterator (this->get_value_traits().to_node_ptr(*pointer_traits<pointer>::const_cast_from(pointer_traits<const_pointer>::pointer_to(value))), this->priv_value_traits_ptr()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void init_node(reference value)
+   inline static void init_node(reference value)
    { node_algorithms::init(value_traits::to_node_ptr(value)); }
 
 };
@@ -314,17 +313,17 @@ struct bstbase2
    typedef BOOST_INTRUSIVE_IMPDEF(typename pointer_traits<const_pointer>::difference_type)      difference_type;
    typedef typename node_algorithms::insert_commit_data insert_commit_data;
 
-   BOOST_INTRUSIVE_FORCEINLINE value_compare value_comp() const
+   inline value_compare value_comp() const
    {  return this->get_comp();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE key_compare key_comp() const
+   inline key_compare key_comp() const
    {  return this->get_comp().key_comp();   }
 
    //lower_bound
-   BOOST_INTRUSIVE_FORCEINLINE iterator lower_bound(const key_type &key)
+   inline iterator lower_bound(const key_type &key)
    {  return this->lower_bound(key, this->key_comp());   }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator lower_bound(const key_type &key) const
+   inline const_iterator lower_bound(const key_type &key) const
    {  return this->lower_bound(key, this->key_comp());   }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -342,7 +341,7 @@ struct bstbase2
    }
 
    //upper_bound
-   BOOST_INTRUSIVE_FORCEINLINE iterator upper_bound(const key_type &key)
+   inline iterator upper_bound(const key_type &key)
    {  return this->upper_bound(key, this->key_comp());   }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -352,7 +351,7 @@ struct bstbase2
          (this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator upper_bound(const key_type &key) const
+   inline const_iterator upper_bound(const key_type &key) const
    {  return this->upper_bound(key, this->key_comp());   }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -367,13 +366,13 @@ struct bstbase2
    {  typedef detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value> type;  };
 
    template<class KeyTypeKeyCompare>
-   BOOST_INTRUSIVE_FORCEINLINE typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const
+   inline typename key_node_comp_ret<KeyTypeKeyCompare>::type key_node_comp(KeyTypeKeyCompare comp) const
    {
       return detail::key_nodeptr_comp<KeyTypeKeyCompare, value_traits, key_of_value>(comp, &this->get_value_traits());
    }
 
    //find
-   BOOST_INTRUSIVE_FORCEINLINE iterator find(const key_type &key)
+   inline iterator find(const key_type &key)
    {  return this->find(key, this->key_comp()); }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -383,7 +382,7 @@ struct bstbase2
          (node_algorithms::find(this->header_ptr(), key, this->key_node_comp(comp)), this->priv_value_traits_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator find(const key_type &key) const
+   inline const_iterator find(const key_type &key) const
    {  return this->find(key, this->key_comp()); }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -394,7 +393,7 @@ struct bstbase2
    }
 
    //equal_range
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type &key)
+   inline std::pair<iterator,iterator> equal_range(const key_type &key)
    {  return this->equal_range(key, this->key_comp());   }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -406,7 +405,7 @@ struct bstbase2
                                           , iterator(ret.second, this->priv_value_traits_ptr()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator>
+   inline std::pair<const_iterator, const_iterator>
       equal_range(const key_type &key) const
    {  return this->equal_range(key, this->key_comp());   }
 
@@ -421,7 +420,7 @@ struct bstbase2
    }
 
    //lower_bound_range
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> lower_bound_range(const key_type &key)
+   inline std::pair<iterator,iterator> lower_bound_range(const key_type &key)
    {  return this->lower_bound_range(key, this->key_comp());   }
 
    template<class KeyType, class KeyTypeKeyCompare>
@@ -433,7 +432,7 @@ struct bstbase2
                                           , iterator(ret.second, this->priv_value_traits_ptr()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator, const_iterator>
+   inline std::pair<const_iterator, const_iterator>
       lower_bound_range(const key_type &key) const
    {  return this->lower_bound_range(key, this->key_comp());   }
 
@@ -448,7 +447,7 @@ struct bstbase2
    }
 
    //bounded_range
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator,iterator> bounded_range
+   inline std::pair<iterator,iterator> bounded_range
       (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed)
    {  return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed);   }
 
@@ -463,7 +462,7 @@ struct bstbase2
                                           , iterator(ret.second, this->priv_value_traits_ptr()));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<const_iterator,const_iterator> bounded_range
+   inline std::pair<const_iterator,const_iterator> bounded_range
       (const key_type &lower_key, const key_type &upper_key, bool left_closed, bool right_closed) const
    {  return this->bounded_range(lower_key, upper_key, this->key_comp(), left_closed, right_closed);   }
 
@@ -479,11 +478,11 @@ struct bstbase2
    }
 
    //insert_unique_check
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check
+   inline std::pair<iterator, bool> insert_unique_check
       (const key_type &key, insert_commit_data &commit_data)
    {  return this->insert_unique_check(key, this->key_comp(), commit_data);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_unique_check
+   inline std::pair<iterator, bool> insert_unique_check
       (const_iterator hint, const key_type &key, insert_commit_data &commit_data)
    {  return this->insert_unique_check(hint, key, this->key_comp(), commit_data);   }
 
@@ -528,7 +527,7 @@ struct bstbase_hack
    typedef typename get_algo
       <AlgoType, node_traits>::type                algo_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
+   inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
       : base_type(comp, vtraits)
    {
       this->sz_traits().set_size(size_type(0));
@@ -536,10 +535,10 @@ struct bstbase_hack
 
    typedef detail::size_holder<ConstantTimeSize, SizeType>     size_traits;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits &sz_traits()
+   inline size_traits &sz_traits()
    {  return static_cast<size_traits &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const size_traits &sz_traits() const
+   inline const size_traits &sz_traits() const
    {  return static_cast<const size_traits &>(*this);  }
 };
 
@@ -551,13 +550,13 @@ struct bstbase_hack<ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, false, SizeTyp
    typedef bstbase2< ValueTraits, VoidOrKeyOfValue, VoidOrKeyComp, AlgoType, HeaderHolder> base_type;
    typedef typename base_type::value_compare       value_compare;
    typedef typename base_type::key_compare         key_compare;
-   BOOST_INTRUSIVE_FORCEINLINE bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
+   inline bstbase_hack(const key_compare & comp, const ValueTraits &vtraits)
       : base_type(comp, vtraits)
    {}
 
    typedef detail::size_holder<false, SizeType>     size_traits;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits sz_traits() const
+   inline size_traits sz_traits() const
    {  return size_traits();  }
 };
 
@@ -579,7 +578,7 @@ struct bstbase
       <AlgoType, node_traits>::type                node_algorithms;
    typedef SizeType                                size_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE bstbase(const key_compare & comp, const ValueTraits &vtraits)
+   inline bstbase(const key_compare & comp, const ValueTraits &vtraits)
       : base_type(comp, vtraits)
    {}
 
@@ -666,7 +665,7 @@ class bstree_impl
    static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
 
    //Constant-time size is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
 
 
    protected:
@@ -742,7 +741,7 @@ class bstree_impl
 
    //! <b>Effects</b>: Equivalent to swap
    //!
-   BOOST_INTRUSIVE_FORCEINLINE bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x)
+   inline bstree_impl& operator=(BOOST_RV_REF(bstree_impl) x)
    {  this->swap(x); return *this;  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -1961,7 +1960,7 @@ class bstree_impl
    //! functor a compilation error will be issued.
    static void remove_node(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!constant_time_size));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!constant_time_size));
       node_ptr to_remove(value_traits::to_node_ptr(value));
       node_algorithms::unlink(to_remove);
       BOOST_IF_CONSTEXPR(safemode_or_autounlink)
@@ -2184,48 +2183,48 @@ class bstree
    typedef typename Base::const_iterator     const_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE bstree()
+   inline bstree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit bstree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE bstree( bool unique, Iterator b, Iterator e
+   inline bstree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bstree(BOOST_RV_REF(bstree) x)
+   inline bstree(BOOST_RV_REF(bstree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bstree& operator=(BOOST_RV_REF(bstree) x)
+   inline bstree& operator=(BOOST_RV_REF(bstree) x)
    {  return static_cast<bstree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const bstree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(bstree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static bstree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const bstree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const bstree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static bstree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<bstree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const bstree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const bstree &>(Base::container_from_iterator(it));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp
index 5113a584b8..45e6b18199 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/bstree_algorithms.hpp
@@ -38,7 +38,7 @@ namespace intrusive {
 template <class NodePtr>
 struct insert_commit_data_t
 {
-   BOOST_INTRUSIVE_FORCEINLINE insert_commit_data_t()
+   inline insert_commit_data_t()
       : link_left(false), node()
    {}
    bool     link_left;
@@ -67,7 +67,7 @@ struct bstree_node_checker
    struct return_type
       : public base_checker_t::return_type
    {
-      BOOST_INTRUSIVE_FORCEINLINE return_type()
+      inline return_type()
          : min_key_node_ptr(const_node_ptr()), max_key_node_ptr(const_node_ptr()), node_count(0)
       {}
 
@@ -76,7 +76,7 @@ struct bstree_node_checker
       size_t   node_count;
    };
 
-   BOOST_INTRUSIVE_FORCEINLINE bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
+   inline bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
       : base_checker_t(extra_checker), comp_(comp)
    {}
 
@@ -186,14 +186,14 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    template<class Disposer>
    struct dispose_subtree_disposer
    {
-      BOOST_INTRUSIVE_FORCEINLINE dispose_subtree_disposer(Disposer &disp, node_ptr subtree)
+      inline dispose_subtree_disposer(Disposer &disp, node_ptr subtree)
          : disposer_(&disp), subtree_(subtree)
       {}
 
-      BOOST_INTRUSIVE_FORCEINLINE void release()
+      inline void release()
       {  disposer_ = 0;  }
 
-      BOOST_INTRUSIVE_FORCEINLINE ~dispose_subtree_disposer()
+      inline ~dispose_subtree_disposer()
       {
          if(disposer_){
             dispose_subtree(subtree_, *disposer_);
@@ -213,7 +213,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT
+   inline static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT
    {  return node_traits::get_left(header);   }
 
    //! <b>Requires</b>: 'header' is the header node of a tree.
@@ -223,7 +223,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT
+   inline static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT
    {  return detail::uncast(header);   }
 
    //! <b>Requires</b>: 'header' is the header node of a tree.
@@ -233,7 +233,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT
+   inline static node_ptr root_node(const_node_ptr header) BOOST_NOEXCEPT
    {
       node_ptr p = node_traits::get_parent(header);
       return p ? p : detail::uncast(header);
@@ -247,7 +247,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT
+   inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT
    { return !NodeTraits::get_parent(n); }
 
    #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -456,7 +456,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!   new_node is not equivalent to node_to_be_replaced according to the
    //!   ordering rules. This function is faster than erasing and inserting
    //!   the node, since no rebalancing and comparison is needed. Experimental function
-   BOOST_INTRUSIVE_FORCEINLINE static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node) BOOST_NOEXCEPT
+   inline static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node) BOOST_NOEXCEPT
    {
       replace_node(node_to_be_replaced, base_type::get_header(node_to_be_replaced), new_node);
    }
@@ -875,7 +875,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: If "comp" throws.
    template<class KeyType, class KeyNodePtrCompare>
-   BOOST_INTRUSIVE_FORCEINLINE static std::pair<node_ptr, node_ptr> equal_range
+   inline static std::pair<node_ptr, node_ptr> equal_range
       (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
    {
       return bounded_range(header, key, key, comp, true, true);
@@ -919,7 +919,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: If "comp" throws.
    template<class KeyType, class KeyNodePtrCompare>
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr lower_bound
+   inline static node_ptr lower_bound
       (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
    {
       return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
@@ -937,7 +937,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: If "comp" throws.
    template<class KeyType, class KeyNodePtrCompare>
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr upper_bound
+   inline static node_ptr upper_bound
       (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
    {
       return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
@@ -960,7 +960,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Notes</b>: This function has only sense if a "insert_unique_check" has been
    //!   previously executed to fill "commit_data". No value should be inserted or
    //!   erased between the "insert_check" and "insert_commit" calls.
-   BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit
+   inline static void insert_unique_commit
       (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data) BOOST_NOEXCEPT
    {  return insert_commit(header, new_value, commit_data); }
 
@@ -1322,7 +1322,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Amortized constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT
+   inline static void erase(node_ptr header, node_ptr z) BOOST_NOEXCEPT
    {
       data_for_rebalance ignored;
       erase(header, z, ignored);
@@ -1341,7 +1341,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: If the comparison throws.
    template<class NodePtrCompare>
-   BOOST_INTRUSIVE_FORCEINLINE static bool transfer_unique
+   inline static bool transfer_unique
       (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
    {
       data_for_rebalance ignored;
@@ -1358,7 +1358,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //!
    //! <b>Throws</b>: If the comparison throws.
    template<class NodePtrCompare>
-   BOOST_INTRUSIVE_FORCEINLINE static void transfer_equal
+   inline static void transfer_equal
       (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
    {
       data_for_rebalance ignored;
@@ -1635,7 +1635,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_left_child(node_ptr p) BOOST_NOEXCEPT
+   inline static bool is_left_child(node_ptr p) BOOST_NOEXCEPT
    {  return NodeTraits::get_left(NodeTraits::get_parent(p)) == p;  }
 
    //! <b>Requires</b>: p is a node of a tree.
@@ -1645,7 +1645,7 @@ class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_right_child(node_ptr p) BOOST_NOEXCEPT
+   inline static bool is_right_child(node_ptr p) BOOST_NOEXCEPT
    {  return NodeTraits::get_right(NodeTraits::get_parent(p)) == p;  }
 
    static void insert_before_check
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp
index ab34c7e309..2c99aa051b 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_list_algorithms.hpp
@@ -80,7 +80,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node); }
 
    //! <b>Effects</b>: Constructs an empty list, making this_node the only
@@ -102,7 +102,7 @@ class circular_list_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       return NodeTraits::get_next(this_node) == this_node;
    }
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp
index 5ce4e8cdba..bc4beaa7e7 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/circular_slist_algorithms.hpp
@@ -146,7 +146,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);  }
 
    //! <b>Requires</b>: 'p' is the first node of a list.
@@ -156,7 +156,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
+   inline static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
    {  return detail::uncast(p);   }
 
    //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@@ -164,7 +164,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == this_node;  }
 
    //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@@ -172,7 +172,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == node_ptr();  }
 
    //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@@ -181,7 +181,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());   }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list.
@@ -193,7 +193,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -203,7 +203,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -213,7 +213,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return get_previous_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node and p must be in the same circular list.
@@ -276,7 +276,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
+   inline static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
    {  base_t::link_after(get_previous_node(nxt_node), this_node);   }
 
    //! <b>Requires</b>: this_node and other_node must be nodes inserted
@@ -453,7 +453,7 @@ class circular_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
    {  return base_t::unlink_after_and_dispose(p, p, disposer);   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp
index 8310231e31..0965079ba9 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/common_slist_algorithms.hpp
@@ -52,7 +52,7 @@ class common_slist_algorithms
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void init(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());  }
 
    static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT
@@ -61,16 +61,16 @@ class common_slist_algorithms
       return !next || next == this_node;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
+   inline static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
    {
       const_node_ptr this_node(NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
+   inline static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(prev_node, last_node);  }
 
    static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
@@ -216,7 +216,7 @@ class common_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
+   inline static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
    {
       node_ptr i = node_traits::get_next(bb);
       node_traits::set_next(bb, node_traits::get_next(i));
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp
index 42f35d2be7..ba665e79ba 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/default_header_holder.hpp
@@ -40,14 +40,14 @@ struct default_header_holder : public NodeTraits::node
 
    default_header_holder() : node() {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node() const
+   inline const_node_ptr get_node() const
    { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node()
+   inline node_ptr get_node()
    { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }
 
    // (unsafe) downcast used to implement container-from-iterator
-   BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(node_ptr p)
+   inline static default_header_holder* get_holder(node_ptr p)
    { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp
index 8883166783..1213112c74 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/ebo_functor_holder.hpp
@@ -166,57 +166,57 @@ class ebo_functor_holder
    public:
    typedef T functor_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
+   inline ebo_functor_holder()
       : t_()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
+   inline explicit ebo_functor_holder(const T &t)
       : t_(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : t_(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
+   inline ebo_functor_holder(const ebo_functor_holder &x)
       : t_(x.t_)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : t_(x.t_)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       this->get() = x.get();
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return t_;}
-   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return t_;}
+   inline T&       get(){return t_;}
+   inline const T& get()const{return t_;}
 
    private:
    T t_;
@@ -231,58 +231,58 @@ class ebo_functor_holder<T, Tag, false>
    public:
    typedef T functor_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
+   inline ebo_functor_holder()
       : T()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
+   inline explicit ebo_functor_holder(const T &t)
       : T(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : T(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
+   inline ebo_functor_holder(const ebo_functor_holder &x)
       : T(static_cast<const T&>(x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : T(BOOST_MOVE_BASE(T, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       const ebo_functor_holder&r = x;
       this->get() = r;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return *this;}
-   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return *this;}
+   inline T&       get(){return *this;}
+   inline const T& get()const{return *this;}
 };
 
 }  //namespace detail {
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp
index c5d9e5305c..48b1f411c3 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/equal_to_value.hpp
@@ -39,7 +39,7 @@ class equal_to_value
       :  t_(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(ConstReference t)const
+   inline bool operator()(ConstReference t)const
    {  return t_ == t;   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp
index 0e21faebaa..f76e89172c 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/exception_disposer.hpp
@@ -41,7 +41,7 @@ class exception_disposer
       :  cont_(&cont), disp_(disp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void release()
+   inline void release()
    {  cont_ = 0;  }
 
    ~exception_disposer()
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp
index 6e43f90d9c..e7b62c6500 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/generic_hook.hpp
@@ -27,7 +27,6 @@
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -41,7 +40,7 @@ struct link_dispatch
 {};
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
+inline void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
 {  //If this assertion raises, you might have destroyed an object
    //while it was still inserted in a container that is alive.
    //If so, remove the object from the container before destroying it.
@@ -49,11 +48,11 @@ BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispat
 }
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
+inline void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
 {  hook.unlink();  }
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
+inline void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
 {}
 
 }  //namespace detail {
@@ -161,54 +160,54 @@ class generic_hook
       < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT
+   inline node_ptr this_ptr() BOOST_NOEXCEPT
    {  return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT
+   inline const_node_ptr this_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
 
    public:
    /// @endcond
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT
+   inline generic_hook() BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& ) BOOST_NOEXCEPT
+   inline generic_hook(const generic_hook& ) BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
+   inline generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
    {  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
+   inline ~generic_hook()
    {
       destructor_impl
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
+   inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes
          (this->this_ptr(), other.this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const BOOST_NOEXCEPT
+   inline bool is_linked() const BOOST_NOEXCEPT
    {
       //is_linked() can be only used in safe-mode or auto-unlink
-      BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
+      BOOST_INTRUSIVE_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
       return !node_algorithms::unique(this->this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void unlink() BOOST_NOEXCEPT
+   inline void unlink() BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
+      BOOST_INTRUSIVE_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
       node_ptr n(this->this_ptr());
       if(!node_algorithms::inited(n)){
          node_algorithms::unlink(n);
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp
index 06713487fc..c33ede0dcd 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/hook_traits.hpp
@@ -28,7 +28,6 @@
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
-#include <boost/assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -47,8 +46,6 @@ struct bhtraits_base
       template rebind_pointer<T>::type                               pointer;
    typedef typename pointer_traits<node_ptr>::
       template rebind_pointer<const T>::type                         const_pointer;
-   //typedef typename pointer_traits<pointer>::reference               reference;
-   //typedef typename pointer_traits<const_pointer>::reference         const_reference;
    typedef T &                                                       reference;
    typedef const T &                                                 const_reference;
    typedef node_holder_type &                                        node_holder_reference;
@@ -56,35 +53,31 @@ struct bhtraits_base
    typedef node&                                                     node_reference;
    typedef const node &                                              const_node_reference;
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
       pointer p = pointer_traits<pointer>::pointer_to
          (static_cast<reference>(static_cast<node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
       const_pointer p = pointer_traits<const_pointer>::pointer_to
          (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       node_ptr p = pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
-      BOOST_ASSERT(!!p);
       return p;
    }
 };
@@ -121,26 +114,26 @@ struct mhtraits
 
    static const link_mode_type link_mode = Hook::hooktags::link_mode;
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {
       return pointer_traits<node_ptr>::pointer_to
          (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {
       return pointer_traits<const_node_ptr>::pointer_to
          (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
             (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
@@ -169,23 +162,23 @@ struct fhtraits
    typedef const value_type &                                        const_reference;
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
-   static node_ptr to_node_ptr(reference value)
+   inline static node_ptr to_node_ptr(reference value)
    {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static const_node_ptr to_node_ptr(const_reference value)
+   inline static const_node_ptr to_node_ptr(const_reference value)
    {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
-   static pointer to_value_ptr(node_ptr n)
+   inline static pointer to_value_ptr(node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
-   static const_pointer to_value_ptr(const_node_ptr n)
+   inline static const_pointer to_value_ptr(const_node_ptr n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
 
    private:
-   static hook_ptr to_hook_ptr(node_ptr n)
+   inline static hook_ptr to_hook_ptr(node_ptr n)
    {  return hook_ptr(&*static_cast<hook_type*>(&*n));  }
 
-   static const_hook_ptr to_hook_ptr(const_node_ptr n)
+   inline static const_hook_ptr to_hook_ptr(const_node_ptr n)
    {  return const_hook_ptr(&*static_cast<const hook_type*>(&*n));  }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp
index 5ab1de2bb1..75b6d83845 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iiterator.hpp
@@ -84,15 +84,15 @@ template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true>
 struct iiterator_members
 {
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
+   inline iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
+   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
       :  nodeptr_(n_ptr), ptr_(data)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
+   inline StoredPointer get_ptr() const
    {  return ptr_;  }
 
    NodePtr nodeptr_;
@@ -102,15 +102,15 @@ struct iiterator_members
 template<class NodePtr, class StoredPointer>
 struct iiterator_members<NodePtr, StoredPointer, false>
 {
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members()
+   inline iiterator_members()
       : nodeptr_()//Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
+   inline iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
       : nodeptr_(n_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE StoredPointer get_ptr() const
+   inline StoredPointer get_ptr() const
    {  return StoredPointer();  }
 
    NodePtr nodeptr_;
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp
index ec91cd4f2c..d0ca41c332 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/iterator.hpp
@@ -181,7 +181,7 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    while(n--)
@@ -197,7 +197,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
 {
    for (; 0 < n; --n)
@@ -207,14 +207,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidire
 }
 
 template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
+inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    it += n;
 }
 
 template<class InputIt, class Distance>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
+inline typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
    make_iterator_advance(InputIt it, Distance n)
 {
    (iterator_advance)(it, n);
@@ -222,14 +222,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
 }
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE 
+inline 
    void iterator_uadvance(It& it, typename iter_size<It>::type n)
 {
    (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
 }
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE
+inline
 It make_iterator_uadvance(It it, typename iter_size<It>::type n)
 {
    (iterator_uadvance)(it, n);
@@ -253,7 +253,7 @@ typename iterator_disable_if_tag_difference_type
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
+inline typename iterator_enable_if_tag_difference_type
    <InputIt, std::random_access_iterator_tag>::type
       iterator_distance(InputIt first, InputIt last)
 {
@@ -266,7 +266,7 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag_difference_type
 ////////////////////////////////////////
 
 template<class It>
-BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
+inline typename iter_size<It>::type
    iterator_udistance(It first, It last)
 {
    return (typename iter_size<It>::type)(iterator_distance)(first, last);
@@ -277,14 +277,14 @@ BOOST_INTRUSIVE_FORCEINLINE typename iter_size<It>::type
 ////////////////////////////////////////
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
+inline InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
 {
    (iterator_advance)(it, n);
    return it;
 }
 
 template<class InputIt>
-BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
+inline InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
 {
    (iterator_uadvance)(it, n);
    return it;
@@ -295,11 +295,11 @@ BOOST_INTRUSIVE_FORCEINLINE InputIt iterator_unext(InputIt it, typename iterator
 ////////////////////////////////////////
 
 template<class I>
-BOOST_INTRUSIVE_FORCEINLINE typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
+inline typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
 {  return i.operator->();  }
 
 template<class T>
-BOOST_INTRUSIVE_FORCEINLINE T * iterator_arrow_result(T *p)
+inline T * iterator_arrow_result(T *p)
 {  return p;   }
 
 } //namespace intrusive
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp
index 1029a3404a..4e7f7c27da 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/key_nodeptr_comp.hpp
@@ -78,40 +78,40 @@ public:
       static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
    };
 
-   BOOST_INTRUSIVE_FORCEINLINE base_t base() const
+   inline base_t base() const
    {  return static_cast<const base_t&>(*this); }
 
-   BOOST_INTRUSIVE_FORCEINLINE key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
+   inline key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
       :  base_t(kcomp), traits_(traits)
    {}
 
    //pred(pnode)
    template<class T1>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
+   inline bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
    {  return base().get()(key_of_value()(*traits_->to_value_ptr(t1)));  }
 
    //operator() 2 arg
    //pred(pnode, pnode)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2));  }
 
    //pred(pnode, key)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), t2);  }
 
    //pred(key, pnode)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, *traits_->to_value_ptr(t2));  }
 
    //pred(key, key)
    template<class T1, class T2>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()
+   inline bool operator()
       (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, t2);  }
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp
index f301a4b8e7..0a10e84872 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/list_iterator.hpp
@@ -60,81 +60,81 @@ class list_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator()
+   inline list_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const list_iterator &other)
+   inline list_iterator(const list_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator(const nonconst_iterator &other)
+   inline list_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(const list_iterator &other)
+   inline list_iterator &operator=(const list_iterator &other)
    {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
+   inline node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator &operator=(node_ptr nodeptr)
+   inline list_iterator &operator=(node_ptr nodeptr)
    {  members_.nodeptr_ = nodeptr;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   inline const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator++()
+   inline list_iterator& operator++()
    {
       node_ptr p = node_traits::get_next(members_.nodeptr_);
       members_.nodeptr_ = p;
       return static_cast<list_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator++(int)
+   inline list_iterator operator++(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator& operator--()
+   inline list_iterator& operator--()
    {
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return static_cast<list_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator operator--(int)
+   inline list_iterator operator--(int)
    {
       list_iterator result (*this);
       members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const list_iterator& l, const list_iterator& r)
+   inline friend bool operator== (const list_iterator& l, const list_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const list_iterator& l, const list_iterator& r)
+   inline friend bool operator!= (const list_iterator& l, const list_iterator& r)
    {  return !(l == r); }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {  return *operator->();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE list_iterator<ValueTraits, false> unconst() const
+   inline list_iterator<ValueTraits, false> unconst() const
    {  return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp
index d86fa4f3c9..cf6c745578 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/mpl.hpp
@@ -66,6 +66,12 @@ using boost::move_detail::eval_if_c;
 using boost::move_detail::eval_if;
 using boost::move_detail::unvoid_ref;
 using boost::move_detail::add_const_if_c;
+using boost::move_detail::is_integral;
+using boost::move_detail::make_unsigned;
+using boost::move_detail::is_enum;
+using boost::move_detail::is_floating_point;
+using boost::move_detail::is_scalar;
+using boost::move_detail::is_unsigned;
 
 template<std::size_t S>
 struct ls_zeros
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp
index 97e8d15326..a836699f32 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/node_cloner_disposer.hpp
@@ -59,7 +59,7 @@ struct node_cloner
    {}
 
    // tree-based containers use this method, which is proxy-reference friendly
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p)
+   inline node_ptr operator()(node_ptr p)
    {
       reference_type v = *traits_->to_value_ptr(p);
       node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
@@ -85,11 +85,11 @@ struct node_disposer
    static const bool safemode_or_autounlink =
       is_safe_autounlink<value_traits::link_mode>::value;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_disposer(F f, const ValueTraits *cont)
+   inline node_disposer(F f, const ValueTraits *cont)
       :  base_t(f), traits_(cont)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
+   inline void operator()(node_ptr p)
    {
       BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(p);
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp
index 275229ab47..8f1156e354 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/parent_from_member.hpp
@@ -26,8 +26,7 @@
 
 #if defined(_MSC_VER)
    #define BOOST_INTRUSIVE_MSVC_ABI_PTR_TO_MEMBER
-   #include <boost/static_assert.hpp>
-#endif
+   #endif
 
 namespace boost {
 namespace intrusive {
@@ -49,7 +48,7 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M
    //MSVC ABI can use up to 3 int32 to represent pointer to member data
    //with virtual base classes, in those cases there is no simple to
    //obtain the address of the parent. So static assert to avoid runtime errors
-   BOOST_STATIC_ASSERT( sizeof(caster) == sizeof(int) );
+   BOOST_INTRUSIVE_STATIC_ASSERT( sizeof(caster) == sizeof(int) );
 
    caster.ptr_to_member = ptr_to_member;
    return std::ptrdiff_t(caster.offset);
@@ -91,25 +90,15 @@ BOOST_INTRUSIVE_FORCEINLINE std::ptrdiff_t offset_from_pointer_to_member(const M
 template<class Parent, class Member>
 BOOST_INTRUSIVE_FORCEINLINE Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
 {
-   return static_cast<Parent*>
-      (
-         static_cast<void*>
-         (
-            static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
-         )
-      );
+   return reinterpret_cast<Parent*>
+      (reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member)));
 }
 
 template<class Parent, class Member>
 BOOST_INTRUSIVE_FORCEINLINE const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
 {
-   return static_cast<const Parent*>
-      (
-         static_cast<const void*>
-         (
-            static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
-         )
-      );
+   return reinterpret_cast<const Parent*>
+      ( reinterpret_cast<std::size_t>(member) - static_cast<std::size_t>(offset_from_pointer_to_member(ptr_to_member)) );
 }
 
 }  //namespace detail {
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp
index 6b9bd4bc63..41d2e24788 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/simple_disposers.hpp
@@ -41,7 +41,7 @@ class init_disposer
    typedef typename NodeAlgorithms::node_ptr node_ptr;
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE void operator()(node_ptr p)
+   inline void operator()(node_ptr p)
    {  NodeAlgorithms::init(p);   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp
index bd14dc5049..ba5f418f9d 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/size_holder.hpp
@@ -33,25 +33,25 @@ struct size_holder
    static const bool constant_time_size = ConstantSize;
    typedef SizeType  size_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE SizeType get_size() const
+   inline SizeType get_size() const
    {  return size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_size(SizeType size)
+   inline void set_size(SizeType size)
    {  size_ = size; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrement()
+   inline void decrement()
    {  --size_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void increment()
+   inline void increment()
    {  ++size_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType n)
+   inline void increase(SizeType n)
    {  size_ += n; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType n)
+   inline void decrease(SizeType n)
    {  size_ -= n; }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder &other)
+   inline void swap(size_holder &other)
    {  SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; }
 
    SizeType size_;
@@ -63,25 +63,25 @@ struct size_holder<false, SizeType, Tag>
    static const bool constant_time_size = false;
    typedef SizeType  size_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type get_size() const
+   inline size_type get_size() const
    {  return 0;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_size(size_type)
+   inline void set_size(size_type)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrement()
+   inline void decrement()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void increment()
+   inline void increment()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void increase(SizeType)
+   inline void increase(SizeType)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void decrease(SizeType)
+   inline void decrease(SizeType)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap(size_holder){}
+   inline void swap(size_holder){}
 };
 
 }  //namespace detail{
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp
index 9c5ee27470..64387c4a75 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/slist_iterator.hpp
@@ -27,7 +27,6 @@
 #include <boost/intrusive/detail/std_fwd.hpp>
 #include <boost/intrusive/detail/iiterator.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -63,75 +62,75 @@ class slist_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator()
+   inline slist_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit slist_iterator(node_ptr nodeptr)
+   inline explicit slist_iterator(node_ptr nodeptr)
       : members_(nodeptr, const_value_traits_ptr())
-   {  BOOST_STATIC_ASSERT((stateful_value_traits == false));  }
+   {  BOOST_INTRUSIVE_STATIC_ASSERT((stateful_value_traits == false));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const slist_iterator &other)
+   inline slist_iterator(const slist_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator(const nonconst_iterator &other)
+   inline slist_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(const slist_iterator &other)
+   inline slist_iterator &operator=(const slist_iterator &other)
    {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
+   inline node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(node_ptr n)
+   inline slist_iterator &operator=(node_ptr n)
    {  members_.nodeptr_ = n;  return static_cast<slist_iterator&>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   inline const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator!() const
+   inline bool operator!() const
    {  return !members_.nodeptr_; }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator& operator++()
+   inline slist_iterator& operator++()
    {
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return static_cast<slist_iterator&> (*this);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator operator++(int)
+   inline slist_iterator operator++(int)
    {
       slist_iterator result (*this);
       members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const slist_iterator& l, const slist_iterator& r)
+   inline friend bool operator== (const slist_iterator& l, const slist_iterator& r)
    {  return l.pointed_node() == r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
+   inline friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
    {  return l.pointed_node() != r.pointed_node();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {  return *operator->();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE slist_iterator<ValueTraits, false> unconst() const
+   inline slist_iterator<ValueTraits, false> unconst() const
    {  return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp
index ba1375f8c8..f97cecb31f 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_iterator.hpp
@@ -68,32 +68,32 @@ class tree_iterator
    typedef typename types_t::iterator_type::reference          reference;
    typedef typename types_t::iterator_type::iterator_category  iterator_category;
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator()
+   inline tree_iterator()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
+   inline explicit tree_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
       : members_(nodeptr, traits_ptr)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const tree_iterator &other)
+   inline tree_iterator(const tree_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator(const nonconst_iterator &other)
+   inline tree_iterator(const nonconst_iterator &other)
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(const tree_iterator &other)
+   inline tree_iterator &operator=(const tree_iterator &other)
    {  members_.nodeptr_ = other.members_.nodeptr_;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(node_ptr nodeptr)
+   inline tree_iterator &operator=(node_ptr nodeptr)
    {  members_.nodeptr_ = nodeptr;  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
+   inline node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
    public:
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator++()
+   inline tree_iterator& operator++()
    {
       members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
       return *this;
@@ -106,7 +106,7 @@ class tree_iterator
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator& operator--()
+   inline tree_iterator& operator--()
    {
       members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
       return *this;
@@ -119,43 +119,43 @@ class tree_iterator
       return result;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_left()
+   inline tree_iterator&  go_left()
    {
       members_.nodeptr_ = node_traits::get_left(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_right()
+   inline tree_iterator&  go_right()
    {
       members_.nodeptr_ = node_traits::get_right(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_iterator&  go_parent()
+   inline tree_iterator&  go_parent()
    {
       members_.nodeptr_ = node_traits::get_parent(members_.nodeptr_);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE operator unspecified_bool_type() const
+   inline operator unspecified_bool_type() const
    {  return members_.nodeptr_ ? &tree_iterator::unspecified_bool_type_func : 0;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator! () const
+   inline bool operator! () const
    {  return !members_.nodeptr_;   }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator== (const tree_iterator& l, const tree_iterator& r)
+   inline friend bool operator== (const tree_iterator& l, const tree_iterator& r)
    { return l.pointed_node() == r.pointed_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
+   inline friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
    {  return !(l == r);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {  return *operator->();   }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr get_value_traits() const
+   inline const_value_traits_ptr get_value_traits() const
    {  return members_.get_ptr();  }
 
    tree_iterator end_iterator_from_it() const
@@ -167,10 +167,10 @@ class tree_iterator
    {  return tree_iterator<value_traits, false>(this->pointed_node(), this->get_value_traits());   }
 
    private:
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::false_) const
+   inline pointer operator_arrow(detail::false_) const
    { return ValueTraits::to_value_ptr(members_.nodeptr_); }
 
-   BOOST_INTRUSIVE_FORCEINLINE pointer operator_arrow(detail::true_) const
+   inline pointer operator_arrow(detail::true_) const
    { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }
 
    iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp
index c78da0acd6..d8b88f62de 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/tree_value_compare.hpp
@@ -59,67 +59,67 @@ struct tree_value_compare
 
    typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
+   inline tree_value_compare()
       :  base_t()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
+   inline explicit tree_value_compare(const key_compare &kcomp)
       :  base_t(kcomp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
+   inline tree_value_compare (const tree_value_compare &x)
       :  base_t(x.base_t::get())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
+   inline tree_value_compare &operator=(const tree_value_compare &x)
    {  this->base_t::get() = x.base_t::get();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
+   inline tree_value_compare &operator=(const key_compare &x)
    {  this->base_t::get() = x;   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
+   inline const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_comp()(key);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value) const
+   inline Ret operator()(const value_type &value) const
    {  return this->key_comp()(KeyOfValue()(value));  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+   inline Ret operator()( const U &nonkey
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
+   inline Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const value_type &value2) const
+   inline Ret operator()(const value_type &value1, const value_type &value2) const
    {  return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const value_type &value2) const
+   inline Ret operator()(const key_type &key1, const value_type &value2) const
    {  return this->key_comp()(key1, KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const key_type &key2) const
+   inline Ret operator()(const value_type &value1, const key_type &key2) const
    {  return this->key_comp()(KeyOfValue()(value1), key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
+   inline Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey1, const key_type &key2
+   inline Ret operator()( const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const value_type &value1, const U &nonvalue2
+   inline Ret operator()( const value_type &value1, const U &nonvalue2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(KeyOfValue()(value1), nonvalue2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonvalue1, const value_type &value2
+   inline Ret operator()( const U &nonvalue1, const value_type &value2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonvalue1, KeyOfValue()(value2));  }
 };
@@ -137,45 +137,45 @@ struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
    typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;
 
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare()
+   inline tree_value_compare()
       :  base_t()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit tree_value_compare(const key_compare &kcomp)
+   inline explicit tree_value_compare(const key_compare &kcomp)
       :  base_t(kcomp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare (const tree_value_compare &x)
+   inline tree_value_compare (const tree_value_compare &x)
       :  base_t(x.base_t::get())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const tree_value_compare &x)
+   inline tree_value_compare &operator=(const tree_value_compare &x)
    {  this->base_t::get() = x.base_t::get();   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE tree_value_compare &operator=(const key_compare &x)
+   inline tree_value_compare &operator=(const key_compare &x)
    {  this->base_t::get() = x;   return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
+   inline const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   inline Ret operator()(const key_type &key) const
    {  return this->key_comp()(key);   }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+   inline Ret operator()( const U &nonkey
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
+   inline Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
+   inline Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const U &nonkey1, const key_type &key2
+   inline Ret operator()(const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 };
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp
index 0011fb5bfb..f925a87a8b 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/detail/workaround.hpp
@@ -48,8 +48,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_INTRUSIVE_FORCEINLINE inline
-#elif defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__))
+#elif defined(BOOST_CLANG) || (defined(BOOST_GCC) && ((__GNUC__ <= 5) || defined(__MINGW32__)))
    //Older GCCs 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_INTRUSIVE_FORCEINLINE inline
 #else
    #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
@@ -81,4 +84,32 @@
 #    define BOOST_INTRUSIVE_CATCH_END }
 #endif
 
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_INTRUSIVE_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#  else
+#     define BOOST_INTRUSIVE_STATIC_ASSERT( B ) static_assert(B, #B)
+#  endif
+#else
+namespace boost {
+namespace intrusive {
+namespace detail {
+
+template<bool B>
+struct STATIC_ASSERTION_FAILURE;
+
+template<>
+struct STATIC_ASSERTION_FAILURE<true>{};
+
+template<unsigned> struct static_assert_test {};
+
+}}}
+
+#define BOOST_INTRUSIVE_STATIC_ASSERT(B) \
+         typedef ::boost::intrusive::detail::static_assert_test<\
+            (unsigned)sizeof(::boost::intrusive::detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\
+               BOOST_JOIN(boost_intrusive_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
 #endif   //#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp
index a616d7ed71..0574f82481 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/linear_slist_algorithms.hpp
@@ -151,8 +151,8 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
-   {  NodeTraits::set_next(this_node, node_ptr ());  }
+   inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   {  NodeTraits::set_next(this_node, node_ptr());  }
 
    //! <b>Requires</b>: 'p' is the first node of a list.
    //!
@@ -161,7 +161,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
+   inline static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
    {  return node_ptr();   }
 
    //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@@ -169,7 +169,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node);  }
 
    //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@@ -177,7 +177,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == this_node;  }
 
    //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@@ -186,7 +186,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);   }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list.
@@ -198,7 +198,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr
+   inline static node_ptr
       get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
@@ -230,7 +230,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
+   inline static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) BOOST_NOEXCEPT
    {
       node_ptr this_nxt    = NodeTraits::get_next(this_node);
       node_ptr other_nxt   = NodeTraits::get_next(other_node);
@@ -400,7 +400,7 @@ class linear_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
    {  return base_t::unlink_after_and_dispose(p, node_ptr(), disposer);   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp
index 62291b4809..9871d97394 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/list.hpp
@@ -37,7 +37,6 @@
 #include <boost/intrusive/detail/algorithm.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <boost/intrusive/detail/value_functors.hpp>
 #include <cstddef>   //std::size_t, etc.
@@ -123,14 +122,14 @@ class list_impl
    static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
 
    //Constant-time size is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(constant_time_size &&
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size &&
                         ((int)value_traits::link_mode == (int)auto_unlink)
                       ));
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node()
+   inline node_ptr get_root_node()
    { return data_.root_plus_size_.m_header.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const
+   inline const_node_ptr get_root_node() const
    { return data_.root_plus_size_.m_header.get_node(); }
 
    struct root_plus_size : public size_traits
@@ -141,29 +140,29 @@ class list_impl
    struct data_t : public value_traits
    {
       typedef typename list_impl::value_traits value_traits;
-      BOOST_INTRUSIVE_FORCEINLINE explicit data_t(const value_traits &val_traits)
+      inline explicit data_t(const value_traits &val_traits)
          :  value_traits(val_traits)
       {}
 
       root_plus_size root_plus_size_;
    } data_;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits() BOOST_NOEXCEPT
+   inline size_traits &priv_size_traits() BOOST_NOEXCEPT
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const BOOST_NOEXCEPT
+   inline const size_traits &priv_size_traits() const BOOST_NOEXCEPT
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const BOOST_NOEXCEPT
+   inline const value_traits &priv_value_traits() const BOOST_NOEXCEPT
    {  return data_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits() BOOST_NOEXCEPT
+   inline value_traits &priv_value_traits() BOOST_NOEXCEPT
    {  return data_;  }
 
    typedef typename boost::intrusive::value_traits_pointers
       <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT
+   inline const_value_traits_ptr priv_value_traits_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits());  }
 
    /// @endcond
@@ -364,7 +363,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT
+   inline reference front() BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@@ -372,7 +371,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT
+   inline const_reference front() const BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a reference to the last element of the list.
@@ -380,7 +379,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference back() BOOST_NOEXCEPT
+   inline reference back() BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the last element of the list.
@@ -388,7 +387,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT
+   inline const_reference back() const BOOST_NOEXCEPT
    { return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); }
 
    //! <b>Effects</b>: Returns an iterator to the first element contained in the list.
@@ -396,7 +395,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT
+   inline iterator begin() BOOST_NOEXCEPT
    { return iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -404,7 +403,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT
+   inline const_iterator begin() const BOOST_NOEXCEPT
    { return this->cbegin(); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -412,7 +411,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT
+   inline const_iterator cbegin() const BOOST_NOEXCEPT
    { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
@@ -420,7 +419,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT
+   inline iterator end() BOOST_NOEXCEPT
    { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -428,7 +427,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT
+   inline const_iterator end() const BOOST_NOEXCEPT
    { return this->cend(); }
 
    //! <b>Effects</b>: Returns a constant iterator to the end of the list.
@@ -436,7 +435,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT
+   inline const_iterator cend() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@@ -445,7 +444,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT
+   inline reverse_iterator rbegin() BOOST_NOEXCEPT
    { return reverse_iterator(this->end()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -454,7 +453,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT
+   inline const_reverse_iterator rbegin() const BOOST_NOEXCEPT
    { return this->crbegin(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -463,7 +462,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT
+   inline const_reverse_iterator crbegin() const BOOST_NOEXCEPT
    { return const_reverse_iterator(end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@@ -472,7 +471,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT
+   inline reverse_iterator rend() BOOST_NOEXCEPT
    { return reverse_iterator(begin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -481,7 +480,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT
+   inline const_reverse_iterator rend() const BOOST_NOEXCEPT
    { return this->crend(); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -490,7 +489,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT
+   inline const_reverse_iterator crend() const BOOST_NOEXCEPT
    { return const_reverse_iterator(this->begin()); }
 
    //! <b>Precondition</b>: end_iterator must be a valid end iterator
@@ -501,7 +500,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static list_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return list_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@@ -512,7 +511,7 @@ class list_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const list_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return list_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
@@ -523,7 +522,7 @@ class list_impl
    //!   if constant-time size option is disabled. Constant time otherwise.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT
+   inline size_type size() const BOOST_NOEXCEPT
    {
       BOOST_IF_CONSTEXPR(constant_time_size)
          return this->priv_size_traits().get_size();
@@ -538,7 +537,7 @@ class list_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT
+   inline bool empty() const BOOST_NOEXCEPT
    {  return node_algorithms::unique(this->get_root_node());   }
 
    //! <b>Effects</b>: Swaps the elements of x and *this.
@@ -563,7 +562,7 @@ class list_impl
    //! <b>Complexity</b>: Linear to the number of shifts.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
+   inline void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
    {  node_algorithms::move_forward(this->get_root_node(), n);  }
 
    //! <b>Effects</b>: Moves forward all the elements, so that the second
@@ -575,7 +574,7 @@ class list_impl
    //! <b>Complexity</b>: Linear to the number of shifts.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE void shift_forward(size_type n = 1) BOOST_NOEXCEPT
+   inline void shift_forward(size_type n = 1) BOOST_NOEXCEPT
    {  node_algorithms::move_backwards(this->get_root_node(), n);  }
 
    //! <b>Effects</b>: Erases the element pointed by i of the list.
@@ -590,7 +589,7 @@ class list_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator i) BOOST_NOEXCEPT
+   inline iterator erase(const_iterator i) BOOST_NOEXCEPT
    {  return this->erase_and_dispose(i, detail::null_disposer());  }
 
    //! <b>Requires</b>: b and e must be valid iterators to elements in *this.
@@ -608,7 +607,7 @@ class list_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased elements.
-   BOOST_INTRUSIVE_FORCEINLINE iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT
+   inline iterator erase(const_iterator b, const_iterator e) BOOST_NOEXCEPT
    {
       BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){
          return this->erase_and_dispose(b, e, detail::null_disposer());
@@ -1187,14 +1186,14 @@ class list_impl
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list. No destructors are called.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee.
+   //! <b>Throws</b>: If the comparison operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1 comparisons calls to pred()).
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void unique()
-   {  this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer());  }
+   {  this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
@@ -1216,7 +1215,7 @@ class list_impl
    //!   elements that are equal from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type throws. Basic guarantee.
+   //! <b>Throws</b>: If the equality operator throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
    //!
@@ -1224,7 +1223,7 @@ class list_impl
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
    void unique_and_dispose(Disposer disposer)
-   {  this->unique_and_dispose(std::equal_to<value_type>(), disposer);  }
+   {  this->unique_and_dispose(value_equal<value_type>(), disposer);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1272,7 +1271,7 @@ class list_impl
    //!   is stateless.
    static iterator s_iterator_to(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(value)));
       return iterator(value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
@@ -1290,7 +1289,7 @@ class list_impl
    //!   is stateless.
    static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
       BOOST_INTRUSIVE_INVARIANT_ASSERT(!node_algorithms::inited(value_traits::to_node_ptr(r)));
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
@@ -1371,22 +1370,22 @@ class list_impl
       return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator!=(const list_impl &x, const list_impl &y)
+   inline friend bool operator!=(const list_impl &x, const list_impl &y)
    {  return !(x == y); }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator<(const list_impl &x, const list_impl &y)
+   inline friend bool operator<(const list_impl &x, const list_impl &y)
    {  return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator>(const list_impl &x, const list_impl &y)
+   inline friend bool operator>(const list_impl &x, const list_impl &y)
    {  return y < x;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator<=(const list_impl &x, const list_impl &y)
+   inline friend bool operator<=(const list_impl &x, const list_impl &y)
    {  return !(y < x);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator>=(const list_impl &x, const list_impl &y)
+   inline friend bool operator>=(const list_impl &x, const list_impl &y)
    {  return !(x < y);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT
+   inline friend void swap(list_impl &x, list_impl &y) BOOST_NOEXCEPT
    {  x.swap(y);  }
 
    /// @cond
@@ -1394,7 +1393,7 @@ class list_impl
    private:
    static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((has_container_from_iterator));
+      BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator));
       node_ptr p = end_iterator.pointed_node();
       header_holder_type* h = header_holder_type::get_holder(p);
       root_plus_size* r = detail::parent_from_member
@@ -1466,7 +1465,7 @@ class list
       #endif
       >::type      Base;
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(list)
 
    public:
@@ -1474,38 +1473,38 @@ class list
    typedef typename Base::iterator              iterator;
    typedef typename Base::const_iterator        const_iterator;
 
-   BOOST_INTRUSIVE_FORCEINLINE list()
+   inline list()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit list(const value_traits &v_traits)
+   inline explicit list(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   inline list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list(BOOST_RV_REF(list) x)
+   inline list(BOOST_RV_REF(list) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE list& operator=(BOOST_RV_REF(list) x)
+   inline list& operator=(BOOST_RV_REF(list) x)
    {  return static_cast<list &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const list &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const list &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(list) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static list &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<list &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const list &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const list &>(Base::container_from_end_iterator(end_iterator));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp
index 66761d7625..20e093e947 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/pack_options.hpp
@@ -14,7 +14,7 @@
 #define BOOST_INTRUSIVE_PACK_OPTIONS_HPP
 
 #include <boost/intrusive/detail/config_begin.hpp>
-
+#include <boost/intrusive/detail/workaround.hpp>
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif
@@ -338,7 +338,7 @@ struct pack_options
 //!
 //!   typedef pack_options< empty_default, typename my_pointer<void*> >::type::my_pointer_type type;
 //!
-//!   BOOST_STATIC_ASSERT(( boost::is_same<type, void>::value ));
+//!   BOOST_INTRUSIVE_STATIC_ASSERT(( boost::is_same<type, void>::value ));
 //!
 //! \endcode
 #define BOOST_INTRUSIVE_OPTION_TYPE(OPTION_NAME, TYPE, TYPEDEF_EXPR, TYPEDEF_NAME)
@@ -368,7 +368,7 @@ struct pack_options
 //!
 //!   const bool is_incremental = pack_options< empty_default, incremental<true> >::type::is_incremental;
 //!
-//!   BOOST_STATIC_ASSERT(( is_incremental == true ));
+//!   BOOST_INTRUSIVE_STATIC_ASSERT(( is_incremental == true ));
 //!
 //! \endcode
 #define BOOST_INTRUSIVE_OPTION_CONSTANT(OPTION_NAME, TYPE, VALUE, CONSTANT_NAME)
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp
index 1b2ed05763..48d984eef6 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/pointer_traits.hpp
@@ -130,7 +130,7 @@ struct pointer_traits
    //!
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>pointer_to</code> is checked.
-   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
    {
       //Non-standard extension, it does not require Ptr::pointer_to. If not present
       //tries to converts &r to pointer.
@@ -150,7 +150,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>static_cast_from</code> is checked.
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer static_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -171,7 +171,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>const_cast_from</code> is checked.
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer const_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -192,7 +192,7 @@ struct pointer_traits
    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
    //!   <code>dynamic_cast_from</code> is checked.
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer dynamic_cast_from(const UPtr &uptr) BOOST_NOEXCEPT
    {
       typedef const UPtr &RefArg;
       const bool value = boost::intrusive::detail::
@@ -208,46 +208,46 @@ struct pointer_traits
    private:
    //priv_to_raw_pointer
    template <class T>
-   BOOST_INTRUSIVE_FORCEINLINE static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
+   inline static T* to_raw_pointer(T* p) BOOST_NOEXCEPT
    {  return p; }
 
    template <class Pointer>
-   BOOST_INTRUSIVE_FORCEINLINE static typename pointer_traits<Pointer>::element_type*
+   inline static typename pointer_traits<Pointer>::element_type*
       to_raw_pointer(const Pointer &p) BOOST_NOEXCEPT
    {  return pointer_traits::to_raw_pointer(p.operator->());  }
 
    //priv_pointer_to
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
+   inline static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) BOOST_NOEXCEPT
    { return Ptr::pointer_to(r); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
+   inline static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) BOOST_NOEXCEPT
    { return pointer(boost::intrusive::detail::addressof(r)); }
 
    //priv_static_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::static_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
 
    //priv_const_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::const_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
 
    //priv_dynamic_cast_from
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) BOOST_NOEXCEPT
    { return Ptr::dynamic_cast_from(uptr); }
 
    template<class UPtr>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
+   inline static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) BOOST_NOEXCEPT
    {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
    ///@endcond
 };
@@ -296,25 +296,25 @@ struct pointer_traits<T*>
 
    //! <b>Returns</b>: addressof(r)
    //!
-   BOOST_INTRUSIVE_FORCEINLINE static pointer pointer_to(reference r) BOOST_NOEXCEPT
+   inline static pointer pointer_to(reference r) BOOST_NOEXCEPT
    { return boost::intrusive::detail::addressof(r); }
 
    //! <b>Returns</b>: static_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer static_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return static_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: const_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer const_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return const_cast<pointer>(uptr);  }
 
    //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
    //!
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
+   inline static pointer dynamic_cast_from(U *uptr) BOOST_NOEXCEPT
    {  return dynamic_cast<pointer>(uptr);  }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp
index 922fce51b0..04fce1eecf 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/rbtree.hpp
@@ -29,7 +29,6 @@
 #include <boost/intrusive/link_mode.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -536,48 +535,48 @@ class rbtree
    typedef typename Base::const_reverse_iterator     const_reverse_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE rbtree()
+   inline rbtree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit rbtree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE rbtree( bool unique, Iterator b, Iterator e
+   inline rbtree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE rbtree(BOOST_RV_REF(rbtree) x)
+   inline rbtree(BOOST_RV_REF(rbtree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE rbtree& operator=(BOOST_RV_REF(rbtree) x)
+   inline rbtree& operator=(BOOST_RV_REF(rbtree) x)
    {  return static_cast<rbtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const rbtree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(rbtree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static rbtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const rbtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static rbtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<rbtree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const rbtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const rbtree &>(Base::container_from_iterator(it));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp
index 9e687da10f..aaee1651c1 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree.hpp
@@ -21,7 +21,6 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
 #include <boost/intrusive/detail/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/intrusive/bs_set_hook.hpp>
 #include <boost/intrusive/bstree.hpp>
 #include <boost/intrusive/detail/tree_node.hpp>
@@ -275,7 +274,7 @@ class sgtree_impl
    typedef typename alpha_traits::multiply_by_alpha_t       multiply_by_alpha_t;
 
    BOOST_MOVABLE_BUT_NOT_COPYABLE(sgtree_impl)
-   BOOST_STATIC_ASSERT(((int)value_traits::link_mode != (int)auto_unlink));
+   BOOST_INTRUSIVE_STATIC_ASSERT(((int)value_traits::link_mode != (int)auto_unlink));
 
    enum { safemode_or_autounlink  =
             (int)value_traits::link_mode == (int)auto_unlink   ||
@@ -914,7 +913,7 @@ class sgtree_impl
    {
       //The alpha factor CAN't be changed if the fixed, floating operation-less
       //1/sqrt(2) alpha factor option is activated
-      BOOST_STATIC_ASSERT((floating_point));
+      BOOST_INTRUSIVE_STATIC_ASSERT((floating_point));
       BOOST_INTRUSIVE_INVARIANT_ASSERT((new_alpha > 0.5f && new_alpha < 1.0f));
       if(new_alpha >= 0.5f && new_alpha < 1.0f){
          float old_alpha = this->get_alpha_traits().get_alpha();
@@ -1018,48 +1017,48 @@ class sgtree
    typedef typename Base::const_reverse_iterator     const_reverse_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE sgtree()
+   inline sgtree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit sgtree(const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE sgtree( bool unique, Iterator b, Iterator e
+   inline sgtree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE sgtree(BOOST_RV_REF(sgtree) x)
+   inline sgtree(BOOST_RV_REF(sgtree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE sgtree& operator=(BOOST_RV_REF(sgtree) x)
+   inline sgtree& operator=(BOOST_RV_REF(sgtree) x)
    {  return static_cast<sgtree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const sgtree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(sgtree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static sgtree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<sgtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const sgtree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const sgtree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static sgtree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<sgtree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const sgtree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const sgtree &>(Base::container_from_iterator(it));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp
index 726dbb9970..ea0d2c54bd 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/sgtree_algorithms.hpp
@@ -287,7 +287,7 @@ class sgtree_algorithms
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(node_ptr,node_ptr,const insert_commit_data&)
    template<class H_Alpha>
-   BOOST_INTRUSIVE_FORCEINLINE static void insert_unique_commit
+   inline static void insert_unique_commit
       (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data
       ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
    {  return insert_commit(header, new_value, commit_data, tree_size, h_alpha, max_tree_size);  }
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp
index 7319bf3132..f39e7dfc2c 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/slist.hpp
@@ -41,7 +41,6 @@
 #include <boost/intrusive/detail/node_cloner_disposer.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
 #include <cstddef>   //std::size_t
 
@@ -166,53 +165,53 @@ class slist_impl
    static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
 
    //Constant-time size is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
    //Linear singly linked lists are incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
    //A list with cached last node is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_end_node()
+   inline node_ptr get_end_node()
    {  return node_algorithms::end_node(this->get_root_node());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_end_node() const
+   inline const_node_ptr get_end_node() const
    {  return node_algorithms::end_node(this->get_root_node());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node()
+   inline node_ptr get_root_node()
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const
+   inline const_node_ptr get_root_node() const
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node()
+   inline node_ptr get_last_node()
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node() const
+   inline const_node_ptr get_last_node() const
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n)
+   inline void set_last_node(node_ptr n)
    {  return this->set_last_node(n, detail::bool_<cache_last>());  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_node(detail::bool_<false>)
+   inline static node_ptr get_last_node(detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
       return node_ptr();
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_last_node(node_ptr , detail::bool_<false>)
+   inline static void set_last_node(node_ptr , detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_last_node(detail::bool_<true>)
+   inline node_ptr get_last_node(detail::bool_<true>)
    {  return node_ptr(data_.root_plus_size_.last_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_last_node(detail::bool_<true>) const
+   inline const_node_ptr get_last_node(detail::bool_<true>) const
    {  return const_node_ptr(data_.root_plus_size_.last_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE void set_last_node(node_ptr n, detail::bool_<true>)
+   inline void set_last_node(node_ptr n, detail::bool_<true>)
    {  data_.root_plus_size_.last_ = n;  }
 
    void set_default_constructed_state()
@@ -241,22 +240,22 @@ class slist_impl
       root_plus_size root_plus_size_;
    } data_;
 
-   BOOST_INTRUSIVE_FORCEINLINE size_traits &priv_size_traits()
+   inline size_traits &priv_size_traits()
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const size_traits &priv_size_traits() const
+   inline const size_traits &priv_size_traits() const
    {  return data_.root_plus_size_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE const value_traits &priv_value_traits() const
+   inline const value_traits &priv_value_traits() const
    {  return data_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE value_traits &priv_value_traits()
+   inline value_traits &priv_value_traits()
    {  return data_;  }
 
    typedef typename boost::intrusive::value_traits_pointers
       <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE const_value_traits_ptr priv_value_traits_ptr() const
+   inline const_value_traits_ptr priv_value_traits_ptr() const
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits());  }
 
    /// @endcond
@@ -449,7 +448,7 @@ class slist_impl
    //!   This function is only available is cache_last<> is true.
    void push_back(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       node_ptr n = priv_value_traits().to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(this->get_last_node(), n);
@@ -501,7 +500,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE reference front() BOOST_NOEXCEPT
+   inline reference front() BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@@ -509,7 +508,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference front() const BOOST_NOEXCEPT
+   inline const_reference front() const BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); }
 
    //! <b>Effects</b>: Returns a reference to the last element of the list.
@@ -522,7 +521,7 @@ class slist_impl
    //!   This function is only available is cache_last<> is true.
    reference back() BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -534,9 +533,9 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    //!   This function is only available is cache_last<> is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_reference back() const BOOST_NOEXCEPT
+   inline const_reference back() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -545,7 +544,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator begin() BOOST_NOEXCEPT
+   inline iterator begin() BOOST_NOEXCEPT
    { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -553,7 +552,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT
+   inline const_iterator begin() const BOOST_NOEXCEPT
    { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -561,7 +560,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT
+   inline const_iterator cbegin() const BOOST_NOEXCEPT
    { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
@@ -569,7 +568,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator end() BOOST_NOEXCEPT
+   inline iterator end() BOOST_NOEXCEPT
    { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -577,7 +576,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT
+   inline const_iterator end() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -585,7 +584,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT
+   inline const_iterator cend() const BOOST_NOEXCEPT
    { return this->end(); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -594,7 +593,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE iterator before_begin() BOOST_NOEXCEPT
+   inline iterator before_begin() BOOST_NOEXCEPT
    { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -603,7 +602,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator before_begin() const BOOST_NOEXCEPT
+   inline const_iterator before_begin() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -612,7 +611,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator cbefore_begin() const BOOST_NOEXCEPT
+   inline const_iterator cbefore_begin() const BOOST_NOEXCEPT
    { return this->before_begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the last element contained in the list.
@@ -622,7 +621,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE iterator last() BOOST_NOEXCEPT
+   inline iterator last() BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -636,7 +635,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator last() const BOOST_NOEXCEPT
+   inline const_iterator last() const BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -650,7 +649,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   BOOST_INTRUSIVE_FORCEINLINE const_iterator clast() const BOOST_NOEXCEPT
+   inline const_iterator clast() const BOOST_NOEXCEPT
    { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Precondition</b>: end_iterator must be a valid end iterator
@@ -661,7 +660,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@@ -672,7 +671,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_INTRUSIVE_FORCEINLINE static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
@@ -683,7 +682,7 @@ class slist_impl
    //!   if constant_time_size is false. Constant time otherwise.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE size_type size() const BOOST_NOEXCEPT
+   inline size_type size() const BOOST_NOEXCEPT
    {
       BOOST_IF_CONSTEXPR(constant_time_size)
          return this->priv_size_traits().get_size();
@@ -698,7 +697,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE bool empty() const BOOST_NOEXCEPT
+   inline bool empty() const BOOST_NOEXCEPT
    {  return node_algorithms::is_empty(this->get_root_node()); }
 
    //! <b>Effects</b>: Swaps the elements of x and *this.
@@ -1061,7 +1060,7 @@ class slist_impl
 
    static iterator s_insert_after(const_iterator const prev_p, reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr const n = value_traits::to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(prev_p.pointed_node(), n);
@@ -1071,7 +1070,7 @@ class slist_impl
    template<class Disposer>
    static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       const_iterator it(prev);
       ++it;
       node_ptr to_erase(it.pointed_node());
@@ -1087,7 +1086,7 @@ class slist_impl
    template<class Disposer>
    static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
       node_ptr fp(node_traits::get_next(bfp));
       node_algorithms::unlink_after(bfp, lp);
@@ -1754,7 +1753,7 @@ class slist_impl
    //!   is stateless.
    static iterator s_iterator_to(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
 
@@ -1771,7 +1770,7 @@ class slist_impl
    //!   is stateless.
    static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
    }
@@ -2112,8 +2111,8 @@ class slist_impl
    {
       //Obtaining the container from the end iterator is not possible with linear
       //singly linked lists (because "end" is represented by the null pointer)
-      BOOST_STATIC_ASSERT(!linear);
-      BOOST_STATIC_ASSERT((has_container_from_iterator));
+      BOOST_INTRUSIVE_STATIC_ASSERT(!linear);
+      BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator));
       node_ptr p = end_iterator.pointed_node();
       header_holder_type* h = header_holder_type::get_holder(p);
       header_holder_plus_last_t* hpl = detail::parent_from_member< header_holder_plus_last_t, header_holder_type>
@@ -2185,7 +2184,7 @@ class slist
       #endif
       >::type   Base;
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(slist)
 
    public:
@@ -2195,45 +2194,45 @@ class slist
    typedef typename Base::size_type          size_type;
    typedef typename Base::node_ptr           node_ptr;
 
-   BOOST_INTRUSIVE_FORCEINLINE slist()
+   inline slist()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit slist(const value_traits &v_traits)
+   inline explicit slist(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    struct incorporate_t{};
 
-   BOOST_INTRUSIVE_FORCEINLINE slist( node_ptr f, node_ptr before_l
+   inline slist( node_ptr f, node_ptr before_l
              , size_type n, const value_traits &v_traits = value_traits())
       :  Base(f, before_l, n, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   inline slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist(BOOST_RV_REF(slist) x)
+   inline slist(BOOST_RV_REF(slist) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE slist& operator=(BOOST_RV_REF(slist) x)
+   inline slist& operator=(BOOST_RV_REF(slist) x)
    {  return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const slist &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const slist &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<slist &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp b/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp
index 44e5c78670..e25647c6ab 100644
--- a/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp
+++ b/contrib/restricted/boost/intrusive/include/boost/intrusive/splaytree.hpp
@@ -18,7 +18,6 @@
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>
 #include <boost/intrusive/detail/minimal_pair_header.hpp>   //std::pair
 
-#include <boost/static_assert.hpp>
 #include <boost/intrusive/bstree.hpp>
 #include <boost/intrusive/detail/tree_node.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
@@ -611,48 +610,48 @@ class splaytree
    typedef typename Base::const_reverse_iterator     const_reverse_iterator;
 
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename value_traits::value_type, T>::value));
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree()
+   inline splaytree()
       :  Base()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
+   inline explicit splaytree( const key_compare &cmp, const value_traits &v_traits = value_traits())
       :  Base(cmp, v_traits)
    {}
 
    template<class Iterator>
-   BOOST_INTRUSIVE_FORCEINLINE splaytree( bool unique, Iterator b, Iterator e
+   inline splaytree( bool unique, Iterator b, Iterator e
          , const key_compare &cmp = key_compare()
          , const value_traits &v_traits = value_traits())
       :  Base(unique, b, e, cmp, v_traits)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree(BOOST_RV_REF(splaytree) x)
+   inline splaytree(BOOST_RV_REF(splaytree) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE splaytree& operator=(BOOST_RV_REF(splaytree) x)
+   inline splaytree& operator=(BOOST_RV_REF(splaytree) x)
    {  return static_cast<splaytree &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const splaytree &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(splaytree) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
+   inline static splaytree &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
+   inline static const splaytree &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const splaytree &>(Base::container_from_end_iterator(end_iterator));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT
+   inline static splaytree &container_from_iterator(iterator it) BOOST_NOEXCEPT
    {  return static_cast<splaytree &>(Base::container_from_iterator(it));   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
+   inline static const splaytree &container_from_iterator(const_iterator it) BOOST_NOEXCEPT
    {  return static_cast<const splaytree &>(Base::container_from_iterator(it));   }
 };
 
diff --git a/contrib/restricted/boost/intrusive/ya.make b/contrib/restricted/boost/intrusive/ya.make
index 0643da6a39..df73bcb529 100644
--- a/contrib/restricted/boost/intrusive/ya.make
+++ b/contrib/restricted/boost/intrusive/ya.make
@@ -9,16 +9,14 @@ LICENSE(
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.84.0)
+VERSION(1.85.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/intrusive/archive/boost-1.84.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/intrusive/archive/boost-1.85.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/assert
     contrib/restricted/boost/config
-    contrib/restricted/boost/container_hash
     contrib/restricted/boost/move
-    contrib/restricted/boost/static_assert
 )
 
 ADDINCL(