Update contrib/restricted/boost/move to 1.85.0

7cf833edab83519b6281153530fb19233e4399fa

18 files changed, 252 insertions, 212 deletions

diff --git a/contrib/restricted/boost/move/include/boost/move/adl_move_swap.hpp b/contrib/restricted/boost/move/include/boost/move/adl_move_swap.hpp
index d9096e36c3..63ad7888e7 100644
--- a/contrib/restricted/boost/move/include/boost/move/adl_move_swap.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/adl_move_swap.hpp
@@ -155,7 +155,7 @@ struct and_op_not
 {};
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y, typename boost::move_detail::enable_if_c<!boost::move_detail::has_move_emulation_enabled_impl<T>::value>::type* = 0)
+inline void swap_proxy(T& x, T& y, typename boost::move_detail::enable_if_c<!boost::move_detail::has_move_emulation_enabled_impl<T>::value>::type* = 0)
 {
    //use std::swap if argument dependent lookup fails
    //Use using directive ("using namespace xxx;") instead as some older compilers
@@ -165,14 +165,14 @@ BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y, typename boost::move_detail::
 }
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
+void swap_proxy(T& x, T& y
                , typename boost::move_detail::enable_if< and_op_not_impl<boost::move_detail::has_move_emulation_enabled_impl<T>
                                                                         , boost_move_member_swap::has_member_swap<T> >
                                                        >::type* = 0)
 {  T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t);  }
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
+inline void swap_proxy(T& x, T& y
                , typename boost::move_detail::enable_if< and_op_impl< boost::move_detail::has_move_emulation_enabled_impl<T>
                                                                     , boost_move_member_swap::has_member_swap<T> >
                                                        >::type* = 0)
@@ -185,7 +185,7 @@ BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y
 namespace boost_move_adl_swap{
 
 template<class T>
-BOOST_MOVE_FORCEINLINE void swap_proxy(T& x, T& y)
+inline void swap_proxy(T& x, T& y)
 {
    using std::swap;
    swap(x, y);
@@ -222,7 +222,7 @@ namespace boost{
 //!   -  Otherwise a move-based swap is called, equivalent to: 
 //!      <code>T t(::boost::move(x)); x = ::boost::move(y); y = ::boost::move(t);</code>.
 template<class T>
-BOOST_MOVE_FORCEINLINE void adl_move_swap(T& x, T& y)
+inline void adl_move_swap(T& x, T& y)
 {
    ::boost_move_adl_swap::swap_proxy(x, y);
 }
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/adaptive_merge.hpp b/contrib/restricted/boost/move/include/boost/move/algo/adaptive_merge.hpp
index bba41bd2ad..5261d72963 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/adaptive_merge.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/adaptive_merge.hpp
@@ -19,6 +19,7 @@
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 namespace boost {
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/detail/adaptive_sort_merge.hpp b/contrib/restricted/boost/move/include/boost/move/algo/detail/adaptive_sort_merge.hpp
index 79c46996e0..2b45407d35 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/detail/adaptive_sort_merge.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/detail/adaptive_sort_merge.hpp
@@ -60,6 +60,7 @@
 #if defined(BOOST_CLANG) || (defined(BOOST_GCC) && (BOOST_GCC >= 40600))
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
 #endif
 
 #ifndef BOOST_MOVE_ADAPTIVE_SORT_STATS_LEVEL
@@ -93,26 +94,12 @@
    #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(L)
 #endif
 
-namespace boost {
-namespace movelib {
-
 #if defined(BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS)
+#include <boost/move/algo/detail/is_sorted.hpp>
+#endif
 
-bool is_sorted(::order_perf_type *first, ::order_perf_type *last, ::order_type_less)
-{
-   if (first != last) {
-      const order_perf_type *next = first, *cur(first);
-      while (++next != last) {
-         if (!(cur->key < next->key || (cur->key == next->key && cur->val < next->val)))
-            return false;
-         cur = next;
-      }
-   }
-   return true;
-}
-
-#endif   //BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
-
+namespace boost {
+namespace movelib {
 namespace detail_adaptive {
 
 static const std::size_t AdaptiveSortInsertionSortThreshold = 16;
@@ -1320,7 +1307,6 @@ void op_merge_blocks_with_buf
          //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
          buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buffer = buf_first, op);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_swp: ", len);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_min, last_min, comp));
          first1 = first2;
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, first1, comp));
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/detail/basic_op.hpp b/contrib/restricted/boost/move/include/boost/move/algo/detail/basic_op.hpp
index 144280b3fc..43ae68d175 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/detail/basic_op.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/detail/basic_op.hpp
@@ -36,19 +36,19 @@ struct four_way_t{};
 struct move_op
 {
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   inline void operator()(SourceIt source, DestinationIt dest)
    {  *dest = ::boost::move(*source);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return ::boost::move(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
+   inline DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
    {  return ::boost::move_backward(first, last, dest_last);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   inline void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       *dest2it = boost::move(*dest1it);
       *dest1it = boost::move(*srcit);
@@ -65,7 +65,7 @@ struct move_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   inline void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       *dest3it = boost::move(*dest2it);
       *dest2it = boost::move(*dest1it);
@@ -76,19 +76,19 @@ struct move_op
 struct swap_op
 {
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   inline void operator()(SourceIt source, DestinationIt dest)
    {  boost::adl_move_swap(*dest, *source);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt>
-   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   inline DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
    {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   inline void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
       *dest2it = boost::move(*dest1it);
@@ -106,7 +106,7 @@ struct swap_op
    }
 
    template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
-   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   inline void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
    {
       typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
       *dest3it = boost::move(*dest2it);
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/detail/heap_sort.hpp b/contrib/restricted/boost/move/include/boost/move/algo/detail/heap_sort.hpp
index 60db353ed8..4ed5a1c7a6 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/detail/heap_sort.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/detail/heap_sort.hpp
@@ -106,7 +106,7 @@ class heap_sort_helper
 };
 
 template <class RandomAccessIterator, class Compare>
-BOOST_MOVE_FORCEINLINE void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
+inline void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
 {
    heap_sort_helper<RandomAccessIterator, Compare>::sort(first, last, comp);
 }
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/detail/merge.hpp b/contrib/restricted/boost/move/include/boost/move/algo/detail/merge.hpp
index ad260046ab..f9f12757e1 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/detail/merge.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/detail/merge.hpp
@@ -43,11 +43,11 @@ class adaptive_xbuf
    typedef RandRawIt iterator;
    typedef SizeType  size_type;
 
-   BOOST_MOVE_FORCEINLINE adaptive_xbuf()
+   inline adaptive_xbuf()
       : m_ptr(), m_size(0), m_capacity(0)
    {}
 
-   BOOST_MOVE_FORCEINLINE adaptive_xbuf(RandRawIt raw_memory, size_type cap)
+   inline adaptive_xbuf(RandRawIt raw_memory, size_type cap)
       : m_ptr(raw_memory), m_size(0), m_capacity(cap)
    {}
 
@@ -102,7 +102,7 @@ class adaptive_xbuf
       }
    }
 
-   BOOST_MOVE_FORCEINLINE void set_size(size_type sz)
+   inline void set_size(size_type sz)
    {
       m_size = sz;
    }
@@ -144,12 +144,12 @@ class adaptive_xbuf
 
    private:
    template<class RIt>
-   BOOST_MOVE_FORCEINLINE static bool is_raw_ptr(RIt)
+   inline static bool is_raw_ptr(RIt)
    {
       return false;
    }
 
-   BOOST_MOVE_FORCEINLINE static bool is_raw_ptr(T*)
+   inline static bool is_raw_ptr(T*)
    {
       return true;
    }
@@ -168,43 +168,43 @@ class adaptive_xbuf
    }
 
    template<class U>
-   BOOST_MOVE_FORCEINLINE U *aligned_trailing() const
+   inline U *aligned_trailing() const
    {
       return this->aligned_trailing<U>(this->size());
    }
 
    template<class U>
-   BOOST_MOVE_FORCEINLINE U *aligned_trailing(size_type pos) const
+   inline U *aligned_trailing(size_type pos) const
    {
       uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
       u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
       return (U*)u_addr;
    }
 
-   BOOST_MOVE_FORCEINLINE ~adaptive_xbuf()
+   inline ~adaptive_xbuf()
    {
       this->clear();
    }
 
-   BOOST_MOVE_FORCEINLINE size_type capacity() const
+   inline size_type capacity() const
    {  return m_capacity;   }
 
-   BOOST_MOVE_FORCEINLINE iterator data() const
+   inline iterator data() const
    {  return m_ptr;   }
 
-   BOOST_MOVE_FORCEINLINE iterator begin() const
+   inline iterator begin() const
    {  return m_ptr;   }
 
-   BOOST_MOVE_FORCEINLINE iterator end() const
+   inline iterator end() const
    {  return m_ptr+m_size;   }
 
-   BOOST_MOVE_FORCEINLINE size_type size() const
+   inline size_type size() const
    {  return m_size;   }
 
-   BOOST_MOVE_FORCEINLINE bool empty() const
+   inline bool empty() const
    {  return !m_size;   }
 
-   BOOST_MOVE_FORCEINLINE void clear()
+   inline void clear()
    {
       this->shrink_to_fit(0u);
    }
diff --git a/contrib/restricted/boost/move/include/boost/move/algo/predicate.hpp b/contrib/restricted/boost/move/include/boost/move/algo/predicate.hpp
index 58a4d620c3..023066a129 100644
--- a/contrib/restricted/boost/move/include/boost/move/algo/predicate.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/algo/predicate.hpp
@@ -24,19 +24,19 @@ namespace movelib {
 template<class Comp>
 struct antistable
 {
-   BOOST_MOVE_FORCEINLINE explicit antistable(Comp &comp)
+   inline explicit antistable(Comp &comp)
       : m_comp(comp)
    {}
 
-   BOOST_MOVE_FORCEINLINE antistable(const antistable & other)
+   inline antistable(const antistable & other)
       : m_comp(other.m_comp)
    {}
 
    template<class U, class V>
-   BOOST_MOVE_FORCEINLINE bool operator()(const U &u, const V & v)
+   inline bool operator()(const U &u, const V & v)
    {  return !m_comp(v, u);  }
 
-   BOOST_MOVE_FORCEINLINE const Comp &get() const
+   inline const Comp &get() const
    {  return m_comp; }
 
    private:
@@ -56,15 +56,15 @@ template <class Comp>
 class negate
 {
    public:
-   BOOST_MOVE_FORCEINLINE negate()
+   inline negate()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit negate(Comp comp)
+   inline explicit negate(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
+   inline bool operator()(const T1& l, const T2& r)
    {
       return !m_comp(l, r);
    }
@@ -78,15 +78,15 @@ template <class Comp>
 class inverse
 {
    public:
-   BOOST_MOVE_FORCEINLINE inverse()
+   inline inverse()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit inverse(Comp comp)
+   inline explicit inverse(Comp comp)
       : m_comp(comp)
    {}
 
    template <class T1, class T2>
-   BOOST_MOVE_FORCEINLINE bool operator()(const T1& l, const T2& r)
+   inline bool operator()(const T1& l, const T2& r)
    {
       return m_comp(r, l);
    }
diff --git a/contrib/restricted/boost/move/include/boost/move/core.hpp b/contrib/restricted/boost/move/include/boost/move/core.hpp
index 68f8f2a126..79205d6526 100644
--- a/contrib/restricted/boost/move/include/boost/move/core.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/core.hpp
@@ -262,12 +262,12 @@
 
    #define BOOST_COPYABLE_AND_MOVABLE(TYPE)\
       public:\
-      BOOST_MOVE_FORCEINLINE TYPE& operator=(TYPE &t)\
+      inline TYPE& operator=(TYPE &t)\
       {  this->operator=(const_cast<const TYPE&>(t)); return *this;}\
       public:\
-      BOOST_MOVE_FORCEINLINE operator ::boost::rv<TYPE>&() \
+      inline operator ::boost::rv<TYPE>&() \
       {  return *BOOST_MOVE_TO_RV_CAST(::boost::rv<TYPE>*, this);  }\
-      BOOST_MOVE_FORCEINLINE operator const ::boost::rv<TYPE>&() const \
+      inline operator const ::boost::rv<TYPE>&() const \
       {  return *BOOST_MOVE_TO_RV_CAST(const ::boost::rv<TYPE>*, this);  }\
       private:\
    //
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/iterator_to_raw_pointer.hpp b/contrib/restricted/boost/move/include/boost/move/detail/iterator_to_raw_pointer.hpp
index 67afd6c1ef..97ee3a6595 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/iterator_to_raw_pointer.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/iterator_to_raw_pointer.hpp
@@ -27,11 +27,11 @@ namespace movelib {
 namespace detail {
 
 template <class T>
-BOOST_MOVE_FORCEINLINE T* iterator_to_pointer(T* i)
+inline T* iterator_to_pointer(T* i)
 {  return i; }
 
 template <class Iterator>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::iterator_traits<Iterator>::pointer
+inline typename boost::movelib::iterator_traits<Iterator>::pointer
    iterator_to_pointer(const Iterator &i)
 {  return i.operator->();  }
 
@@ -46,7 +46,7 @@ struct iterator_to_element_ptr
 }  //namespace detail {
 
 template <class Iterator>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
+inline typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
    iterator_to_raw_pointer(const Iterator &i)
 {
    return ::boost::movelib::to_raw_pointer
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/meta_utils.hpp b/contrib/restricted/boost/move/include/boost/move/detail/meta_utils.hpp
index 7c90de287e..ad5654a395 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/meta_utils.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/meta_utils.hpp
@@ -57,8 +57,8 @@ struct apply
 template< bool C_ >
 struct bool_ : integral_constant<bool, C_>
 {
-   BOOST_MOVE_FORCEINLINE operator bool() const { return C_; }
-   BOOST_MOVE_FORCEINLINE bool operator()() const { return C_; }
+   inline operator bool() const { return C_; }
+   inline bool operator()() const { return C_; }
 };
 
 typedef bool_<true>        true_;
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/move_helpers.hpp b/contrib/restricted/boost/move/include/boost/move/detail/move_helpers.hpp
index 17138444d1..89c73a090b 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/move_helpers.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/move_helpers.hpp
@@ -69,13 +69,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+      inline RETURN_VALUE PUB_FUNCTION(TYPE &x)\
       {  return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -83,12 +83,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -100,12 +100,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -116,14 +116,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c\
+      inline typename ::boost::move_detail::enable_if_c\
                         < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
                         , RETURN_VALUE >::type\
       PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
@@ -136,10 +136,10 @@
 #else    //BOOST_NO_CXX11_RVALUE_REFERENCES
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(x); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
    //
 
@@ -174,13 +174,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
       {  return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -188,12 +188,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -205,12 +205,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         inline typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -222,14 +222,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::disable_if_or\
+      inline typename ::boost::move_detail::disable_if_or\
                         < RETURN_VALUE \
                         , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
                         , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
@@ -244,10 +244,10 @@
 #else
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      inline RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
    //
 
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/reverse_iterator.hpp b/contrib/restricted/boost/move/include/boost/move/detail/reverse_iterator.hpp
index 7fda6edf0d..19fb2877c6 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/reverse_iterator.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/reverse_iterator.hpp
@@ -29,7 +29,7 @@ namespace boost {
 namespace movelib {
 
 template<class I>
-BOOST_MOVE_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>
@@ -49,38 +49,38 @@ class reverse_iterator
 
    typedef It iterator_type;
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator()
+   inline reverse_iterator()
       : m_current()  //Value initialization to achieve "null iterators" (N3644)
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit reverse_iterator(It r)
+   inline explicit reverse_iterator(It r)
       : m_current(r)
    {}
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator(const reverse_iterator& r)
+   inline reverse_iterator(const reverse_iterator& r)
       : m_current(r.base())
    {}
 
    template<class OtherIt>
-   BOOST_MOVE_FORCEINLINE
+   inline
       reverse_iterator( const reverse_iterator<OtherIt>& r
                       , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
                    )
       : m_current(r.base())
    {}
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator & operator=( const reverse_iterator& r)
+   inline reverse_iterator & operator=( const reverse_iterator& r)
    {  m_current = r.base();   return *this;  }
 
    template<class OtherIt>
-   BOOST_MOVE_FORCEINLINE typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
+   inline typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
          operator=( const reverse_iterator<OtherIt>& r)
    {  m_current = r.base();   return *this;  }
 
-   BOOST_MOVE_FORCEINLINE It base() const
+   inline It base() const
    {  return m_current;  }
 
-   BOOST_MOVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {
       It temp(m_current);
       --temp;
@@ -88,78 +88,78 @@ class reverse_iterator
       return r;
    }
 
-   BOOST_MOVE_FORCEINLINE pointer operator->() const
+   inline pointer operator->() const
    {
       It temp(m_current);
       --temp;
       return (iterator_arrow_result)(temp);
    }
 
-   BOOST_MOVE_FORCEINLINE reference operator[](difference_type off) const
+   inline reference operator[](difference_type off) const
    {
       return this->m_current[difference_type(-off - 1)];
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator++()
+   inline reverse_iterator& operator++()
    {
       --m_current;
       return *this;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator operator++(int)
+   inline reverse_iterator operator++(int)
    {
       reverse_iterator temp((*this));
       --m_current;
       return temp;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator--()
+   inline reverse_iterator& operator--()
    {
       ++m_current;
       return *this;
    }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator operator--(int)
+   inline reverse_iterator operator--(int)
    {
       reverse_iterator temp((*this));
       ++m_current;
       return temp;
    }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current == r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current != r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current > r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current >= r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current < r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
    {  return l.m_current <= r.m_current;  }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator+=(difference_type off)
+   inline reverse_iterator& operator+=(difference_type off)
    {  m_current -= off; return *this;  }
 
-   BOOST_MOVE_FORCEINLINE reverse_iterator& operator-=(difference_type off)
+   inline reverse_iterator& operator-=(difference_type off)
    {  m_current += off; return *this;  }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(reverse_iterator l, difference_type off)
+   inline friend reverse_iterator operator+(reverse_iterator l, difference_type off)
    {  return (l += off);  }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator+(difference_type off, reverse_iterator r)
+   inline friend reverse_iterator operator+(difference_type off, reverse_iterator r)
    {  return (r += off);   }
 
-   BOOST_MOVE_FORCEINLINE friend reverse_iterator operator-(reverse_iterator l, difference_type off)
+   inline friend reverse_iterator operator-(reverse_iterator l, difference_type off)
    {  return (l-= off);  }
 
-   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
+   inline friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
    {  return r.m_current - l.m_current;  }
 
    private:
@@ -167,7 +167,7 @@ class reverse_iterator
 };
 
 template< class Iterator >
-BOOST_MOVE_FORCEINLINE reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
+inline reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
 {  return reverse_iterator<Iterator>(i);  }
 
 } //namespace movelib {
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/to_raw_pointer.hpp b/contrib/restricted/boost/move/include/boost/move/detail/to_raw_pointer.hpp
index 7e89beb4db..06beb2d42c 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/to_raw_pointer.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/to_raw_pointer.hpp
@@ -33,7 +33,7 @@ BOOST_MOVE_FORCEINLINE T* to_raw_pointer(T* p)
 {  return p; }
 
 template <class Pointer>
-BOOST_MOVE_FORCEINLINE typename boost::movelib::pointer_element<Pointer>::type*
+inline typename boost::movelib::pointer_element<Pointer>::type*
 to_raw_pointer(const Pointer &p)
 {  return ::boost::movelib::to_raw_pointer(p.operator->());  }
 
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/type_traits.hpp b/contrib/restricted/boost/move/include/boost/move/detail/type_traits.hpp
index 5a093186cb..84dcbceb73 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/type_traits.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/type_traits.hpp
@@ -582,6 +582,28 @@ struct remove_cvref
 };
 
 //////////////////////////
+//    is_unsigned
+//////////////////////////
+template<class T> struct is_unsigned_cv               { static const bool value = true; };
+template <>       struct is_unsigned_cv<signed char>  { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed short> { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed int>   { static const bool value = false; };
+template <>       struct is_unsigned_cv<signed long>  { static const bool value = false; };
+#ifdef BOOST_HAS_LONG_LONG
+template <>       struct is_unsigned_cv< ::boost::long_long_type > { static const bool value = false; };
+#endif
+
+#ifdef BOOST_HAS_INT128
+template <>       struct is_unsigned_cv< ::boost::int128_type >    { static const bool value = false; };
+#endif
+
+template <class T>
+struct is_unsigned
+   : is_unsigned_cv<typename remove_cv<T>::type>
+{};
+
+
+//////////////////////////
 //    make_unsigned
 //////////////////////////
 template <class T>
@@ -594,6 +616,11 @@ template <> struct make_unsigned_impl<signed long>                {  typedef uns
 template <> struct make_unsigned_impl< ::boost::long_long_type >  {  typedef ::boost::ulong_long_type type; };
 #endif
 
+#ifdef BOOST_HAS_INT128
+template <> struct make_unsigned_impl< ::boost::int128_type > { typedef ::boost::uint128_type type; };
+#endif
+
+
 template <class T>
 struct make_unsigned
    : make_unsigned_impl<typename remove_cv<T>::type>
@@ -639,6 +666,13 @@ template<> struct is_integral_cv<            unsigned long>{  static const bool
 template<> struct is_integral_cv< ::boost:: long_long_type>{  static const bool value = true; };
 template<> struct is_integral_cv< ::boost::ulong_long_type>{  static const bool value = true; };
 #endif
+#ifdef BOOST_HAS_INT128
+template <> struct is_integral_cv< ::boost::int128_type >  {  static const bool value = true; };
+template <> struct is_integral_cv< ::boost::uint128_type > {  static const bool value = true; };
+#endif
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+template<> struct is_integral_cv<char8_t>  { static const bool value = true; };
+#endif
 
 template<class T>
 struct is_integral
@@ -661,13 +695,6 @@ struct remove_all_extents<T[N]>
 {  typedef typename remove_all_extents<T>::type type;};
 
 //////////////////////////
-//    is_scalar
-//////////////////////////
-template<class T>
-struct is_scalar
-{  static const bool value = is_integral<T>::value || is_floating_point<T>::value; };
-
-//////////////////////////
 //       is_void
 //////////////////////////
 template<class T>
@@ -732,6 +759,11 @@ struct is_nullptr_t
    : is_nullptr_t_cv<typename remove_cv<T>::type>
 {};
 
+template <class T>
+struct is_null_pointer
+   : is_nullptr_t_cv<typename remove_cv<T>::type>
+{};
+
 //////////////////////////////////////
 //          is_function
 //////////////////////////////////////
@@ -802,6 +834,7 @@ struct is_arithmetic
                              is_integral<T>::value;
 };
 
+
 //////////////////////////////////////
 //    is_member_function_pointer
 //////////////////////////////////////
@@ -829,21 +862,38 @@ struct is_member_function_pointer
 template <class T>
 struct is_enum_nonintrinsic
 {
-   static const bool value =  !is_arithmetic<T>::value     &&
-                              !is_reference<T>::value      &&
-                              !is_class_or_union<T>::value &&
-                              !is_array<T>::value          &&
-                              !is_void<T>::value           &&
-                              !is_nullptr_t<T>::value      &&
-                              !is_member_pointer<T>::value &&
-                              !is_pointer<T>::value        &&
-                              !is_function<T>::value;
+   static const bool value = !is_arithmetic<T>::value &&
+      !is_reference<T>::value &&
+      !is_class_or_union<T>::value &&
+      !is_array<T>::value &&
+      !is_void<T>::value &&
+      !is_nullptr_t<T>::value &&
+      !is_member_pointer<T>::value &&
+      !is_pointer<T>::value &&
+      !is_function<T>::value;
 };
 #endif
 
 template <class T>
 struct is_enum
-{  static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T);  };
+{
+   static const bool value = BOOST_MOVE_IS_ENUM_IMPL(T);
+};
+
+
+//////////////////////////
+//    is_scalar
+//////////////////////////
+template<class T>
+struct is_scalar
+{
+   static const bool value = is_arithmetic<T>::value ||
+      is_enum<T>::value ||
+      is_pointer<T>::value ||
+      is_member_pointer<T>::value ||
+      is_null_pointer<T>::value;
+};
+
 
 //////////////////////////////////////
 //       is_pod
diff --git a/contrib/restricted/boost/move/include/boost/move/detail/workaround.hpp b/contrib/restricted/boost/move/include/boost/move/detail/workaround.hpp
index 2fcd027d8d..5edfcee1f2 100644
--- a/contrib/restricted/boost/move/include/boost/move/detail/workaround.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/detail/workaround.hpp
@@ -61,8 +61,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_MOVE_FORCEINLINE inline
-#elif defined(BOOST_GCC) && (__GNUC__ <= 5)
+#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_MOVE_FORCEINLINE inline
 #else
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
@@ -126,7 +129,7 @@ template<unsigned> struct static_assert_test {};
 #define BOOST_MOVE_STATIC_ASSERT(B) \
          typedef ::boost::move_detail::static_assert_test<\
             (unsigned)sizeof(::boost::move_detail::STATIC_ASSERTION_FAILURE<bool(B)>)>\
-               BOOST_JOIN(boost_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
+               BOOST_JOIN(boost_move_static_assert_typedef_, __LINE__) BOOST_ATTRIBUTE_UNUSED
 
 #endif
 
diff --git a/contrib/restricted/boost/move/include/boost/move/iterator.hpp b/contrib/restricted/boost/move/include/boost/move/iterator.hpp
index c289c08364..7d1636e050 100644
--- a/contrib/restricted/boost/move/include/boost/move/iterator.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/iterator.hpp
@@ -58,20 +58,20 @@ class move_iterator
    typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type   difference_type;
    typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category;
 
-   BOOST_MOVE_FORCEINLINE move_iterator()
+   inline move_iterator()
       : m_it()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit move_iterator(const It &i)
+   inline explicit move_iterator(const It &i)
       :  m_it(i)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE move_iterator(const move_iterator<U>& u)
+   inline move_iterator(const move_iterator<U>& u)
       :  m_it(u.m_it)
    {}
 
-   BOOST_MOVE_FORCEINLINE reference operator*() const
+   inline reference operator*() const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return *m_it;
@@ -80,34 +80,34 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE pointer   operator->() const
+   inline pointer   operator->() const
    {  return m_it;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator++()
+   inline move_iterator& operator++()
    {  ++m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator++(int)
+   inline move_iterator<iterator_type>  operator++(int)
    {  move_iterator<iterator_type> tmp(*this); ++(*this); return tmp;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator--()
+   inline move_iterator& operator--()
    {  --m_it; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator--(int)
+   inline move_iterator<iterator_type>  operator--(int)
    {  move_iterator<iterator_type> tmp(*this); --(*this); return tmp;   }
 
    move_iterator<iterator_type>  operator+ (difference_type n) const
    {  return move_iterator<iterator_type>(m_it + n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator+=(difference_type n)
+   inline move_iterator& operator+=(difference_type n)
    {  m_it += n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE move_iterator<iterator_type>  operator- (difference_type n) const
+   inline move_iterator<iterator_type>  operator- (difference_type n) const
    {  return move_iterator<iterator_type>(m_it - n);  }
 
-   BOOST_MOVE_FORCEINLINE move_iterator& operator-=(difference_type n)
+   inline move_iterator& operator-=(difference_type n)
    {  m_it -= n; return *this;   }
 
-   BOOST_MOVE_FORCEINLINE reference operator[](difference_type n) const
+   inline reference operator[](difference_type n) const
    {
       #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES)
       return m_it[n];
@@ -116,28 +116,28 @@ class move_iterator
       #endif
    }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator==(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator==(const move_iterator& x, const move_iterator& y)
    {  return x.m_it == y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator!=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator!=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it != y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator< (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator< (const move_iterator& x, const move_iterator& y)
    {  return x.m_it < y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator<=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator<=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it <= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator> (const move_iterator& x, const move_iterator& y)
+   inline friend bool operator> (const move_iterator& x, const move_iterator& y)
    {  return x.m_it > y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend bool operator>=(const move_iterator& x, const move_iterator& y)
+   inline friend bool operator>=(const move_iterator& x, const move_iterator& y)
    {  return x.m_it >= y.m_it;  }
 
-   BOOST_MOVE_FORCEINLINE friend difference_type operator-(const move_iterator& x, const move_iterator& y)
+   inline friend difference_type operator-(const move_iterator& x, const move_iterator& y)
    {  return x.m_it - y.m_it;   }
 
-   BOOST_MOVE_FORCEINLINE friend move_iterator operator+(difference_type n, const move_iterator& x)
+   inline friend move_iterator operator+(difference_type n, const move_iterator& x)
    {  return move_iterator(x.m_it + n);   }
 
    private:
@@ -170,7 +170,7 @@ struct is_move_iterator< ::boost::move_iterator<I> >
 //!
 //! <b>Returns</b>: move_iterator<It>(i).
 template<class It>
-BOOST_MOVE_FORCEINLINE move_iterator<It> make_move_iterator(const It &it)
+inline move_iterator<It> make_move_iterator(const It &it)
 {  return move_iterator<It>(it); }
 
 //////////////////////////////////////////////////////////////////////////////
diff --git a/contrib/restricted/boost/move/include/boost/move/unique_ptr.hpp b/contrib/restricted/boost/move/include/boost/move/unique_ptr.hpp
index 2102872285..6a9bb67a94 100644
--- a/contrib/restricted/boost/move/include/boost/move/unique_ptr.hpp
+++ b/contrib/restricted/boost/move/include/boost/move/unique_ptr.hpp
@@ -92,25 +92,25 @@ struct unique_ptr_data
    typedef typename deleter_types<D>::del_ref            del_ref;
    typedef typename deleter_types<D>::del_cref           del_cref;
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT
+   inline unique_ptr_data() BOOST_NOEXCEPT
       : m_p(), d()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT
+   inline explicit unique_ptr_data(P p) BOOST_NOEXCEPT
       : m_p(p), d()
    {}
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
       : m_p(p), d(d1)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, BOOST_FWD_REF(U) d1) BOOST_NOEXCEPT
       : m_p(p), d(::boost::forward<U>(d1))
    {}
 
-   BOOST_MOVE_FORCEINLINE del_ref deleter()       { return d; }
-   BOOST_MOVE_FORCEINLINE del_cref deleter() const{ return d; }
+   inline del_ref deleter()       { return d; }
+   inline del_cref deleter() const{ return d; }
 
    P m_p;
    D d;
@@ -128,25 +128,25 @@ struct unique_ptr_data<P, D, false>
    typedef typename deleter_types<D>::del_ref            del_ref;
    typedef typename deleter_types<D>::del_cref           del_cref;
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data() BOOST_NOEXCEPT
+   inline unique_ptr_data() BOOST_NOEXCEPT
       : D(), m_p()
    {}
 
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr_data(P p) BOOST_NOEXCEPT
+   inline explicit unique_ptr_data(P p) BOOST_NOEXCEPT
       : D(), m_p(p)
    {}
 
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, deleter_arg_type1 d1) BOOST_NOEXCEPT
       : D(d1), m_p(p)
    {}
 
    template <class U>
-   BOOST_MOVE_FORCEINLINE unique_ptr_data(P p, BOOST_FWD_REF(U) d) BOOST_NOEXCEPT
+   inline unique_ptr_data(P p, BOOST_FWD_REF(U) d) BOOST_NOEXCEPT
       : D(::boost::forward<U>(d)), m_p(p)
    {}
 
-   BOOST_MOVE_FORCEINLINE del_ref deleter()        BOOST_NOEXCEPT   {  return static_cast<del_ref>(*this);   }
-   BOOST_MOVE_FORCEINLINE del_cref deleter() const BOOST_NOEXCEPT   {  return static_cast<del_cref>(*this);  }
+   inline del_ref deleter()        BOOST_NOEXCEPT   {  return static_cast<del_ref>(*this);   }
+   inline del_cref deleter() const BOOST_NOEXCEPT   {  return static_cast<del_cref>(*this);  }
 
    P m_p;
 
@@ -388,7 +388,7 @@ class unique_ptr
    //!
    //! <b>Remarks</b>: If this constructor is instantiated with a pointer type or reference type
    //!   for the template argument D, the program is ill-formed.   
-   BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT
+   inline BOOST_CONSTEXPR unique_ptr() BOOST_NOEXCEPT
       : m_data()
    {
       //If this constructor is instantiated with a pointer type or reference type
@@ -399,7 +399,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor).
    //! 
-   BOOST_MOVE_FORCEINLINE BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+   inline BOOST_CONSTEXPR unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
       : m_data()
    {
       //If this constructor is instantiated with a pointer type or reference type
@@ -422,7 +422,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE explicit unique_ptr(Pointer p
+   inline explicit unique_ptr(Pointer p
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
                  ) BOOST_NOEXCEPT
       : m_data(p)
@@ -460,7 +460,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
+   inline unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type1) d1
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
               ) BOOST_NOEXCEPT
       : m_data(p, d1)
@@ -473,7 +473,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type1 d1)</tt>
    //!   and additionally <tt>get() == nullptr</tt>
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type1) d1) BOOST_NOEXCEPT
       : m_data(pointer(), d1)
    {}
 
@@ -498,7 +498,7 @@ class unique_ptr
    //!      - If T is not an array type and Pointer is implicitly convertible to pointer.
    //!      - If T is an array type and Pointer is a more CV qualified pointer to element_type.
    template<class Pointer>
-   BOOST_MOVE_FORCEINLINE unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
+   inline unique_ptr(Pointer p, BOOST_MOVE_SEEDOC(deleter_arg_type2) d2
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_ptr<T BOOST_MOVE_I Pointer BOOST_MOVE_I pointer>::type* =0)
              ) BOOST_NOEXCEPT
       : m_data(p, ::boost::move(d2))
@@ -511,7 +511,7 @@ class unique_ptr
 
    //! <b>Effects</b>: Same effects as <tt>template<class Pointer> unique_ptr(Pointer p, deleter_arg_type2 d2)</tt>
    //!   and additionally <tt>get() == nullptr</tt>
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), BOOST_MOVE_SEEDOC(deleter_arg_type2) d2) BOOST_NOEXCEPT
       : m_data(pointer(), ::boost::move(d2))
    {}
 
@@ -525,7 +525,7 @@ class unique_ptr
    //! <b>Postconditions</b>: <tt>get()</tt> yields the value u.get() yielded before the construction. <tt>get_deleter()</tt>
    //! returns a reference to the stored deleter that was constructed from u.get_deleter(). If D is a
    //! reference type then <tt>get_deleter()</tt> and <tt>u.get_deleter()</tt> both reference the same lvalue deleter.
-   BOOST_MOVE_FORCEINLINE unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
+   inline unique_ptr(BOOST_RV_REF(unique_ptr) u) BOOST_NOEXCEPT
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<D>(u.get_deleter()))
    {}
 
@@ -545,7 +545,7 @@ class unique_ptr
    //! <b>Postconditions</b>: <tt>get()</tt> yields the value <tt>u.get()</tt> yielded before the construction. <tt>get_deleter()</tt>
    //!   returns a reference to the stored deleter that was constructed from <tt>u.get_deleter()</tt>.
    template <class U, class E>
-   BOOST_MOVE_FORCEINLINE unique_ptr( BOOST_RV_REF_BEG_IF_CXX11 unique_ptr<U, E> BOOST_RV_REF_END_IF_CXX11 u
+   inline unique_ptr( BOOST_RV_REF_BEG_IF_CXX11 unique_ptr<U, E> BOOST_RV_REF_END_IF_CXX11 u
       BOOST_MOVE_DOCIGN(BOOST_MOVE_I typename bmupd::enable_up_moveconv_constr<T BOOST_MOVE_I D BOOST_MOVE_I U BOOST_MOVE_I E>::type* =0)
       ) BOOST_NOEXCEPT
       : m_data(u.release(), ::boost::move_if_not_lvalue_reference<E>(u.get_deleter()))
@@ -628,7 +628,7 @@ class unique_ptr
    //! <b>Returns</b>: <tt>get()[i]</tt>.
    //!
    //! <b>Remarks</b: If T is not an array type, the program is ill-formed.
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
+   inline BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
       operator[](std::size_t i) const BOOST_NOEXCEPT
    {
       assert( bmupmu::extent<T>::value == 0 || i < bmupmu::extent<T>::value );
@@ -643,7 +643,7 @@ class unique_ptr
    //! <b>Note</b>: use typically requires that T be a complete type.
    //!
    //! <b>Remarks</b: If T is an array type, the program is ill-formed.
-   BOOST_MOVE_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT
+   inline pointer operator->() const BOOST_NOEXCEPT
    {
       BOOST_MOVE_STATIC_ASSERT((!bmupmu::is_array<T>::value));
       assert(m_data.m_p);
@@ -652,27 +652,27 @@ class unique_ptr
 
    //! <b>Returns</b>: The stored pointer.
    //!
-   BOOST_MOVE_FORCEINLINE pointer get() const BOOST_NOEXCEPT
+   inline pointer get() const BOOST_NOEXCEPT
    {  return m_data.m_p;  }
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(D&, typename bmupmu::add_lvalue_reference<D>::type)
+   inline BOOST_MOVE_DOC1ST(D&, typename bmupmu::add_lvalue_reference<D>::type)
       get_deleter() BOOST_NOEXCEPT
    {  return m_data.deleter();  }   
 
    //! <b>Returns</b>: A reference to the stored deleter.
    //!
-   BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(const D&, typename bmupmu::add_const_lvalue_reference<D>::type)
+   inline BOOST_MOVE_DOC1ST(const D&, typename bmupmu::add_const_lvalue_reference<D>::type)
       get_deleter() const BOOST_NOEXCEPT
    {  return m_data.deleter();  }
 
    #ifdef BOOST_MOVE_DOXYGEN_INVOKED
    //! <b>Returns</b>: Returns: get() != nullptr.
    //!
-   BOOST_MOVE_FORCEINLINE explicit operator bool
+   inline explicit operator bool
    #else
-   BOOST_MOVE_FORCEINLINE operator bmupd::explicit_bool_arg
+   inline operator bmupd::explicit_bool_arg
    #endif
       ()const BOOST_NOEXCEPT
    {
@@ -684,7 +684,7 @@ class unique_ptr
    //! <b>Postcondition</b>: <tt>get() == nullptr</tt>.
    //!
    //! <b>Returns</b>: The value <tt>get()</tt> had at the start of the call to release.   
-   BOOST_MOVE_FORCEINLINE pointer release() BOOST_NOEXCEPT
+   inline pointer release() BOOST_NOEXCEPT
    {
       const pointer tmp = m_data.m_p;
       m_data.m_p = pointer();
@@ -747,19 +747,19 @@ class unique_ptr
 //! <b>Effects</b>: Calls <tt>x.swap(y)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) BOOST_NOEXCEPT
+inline void swap(unique_ptr<T, D> &x, unique_ptr<T, D> &y) BOOST_NOEXCEPT
 {  x.swap(y); }
 
 //! <b>Returns</b>: <tt>x.get() == y.get()</tt>.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator==(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() == y.get(); }
 
 //! <b>Returns</b>: <tt>x.get() != y.get()</tt>.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator!=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() != y.get(); }
 
 //! <b>Returns</b>: x.get() < y.get().
@@ -767,99 +767,99 @@ BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T1, D1> &x, const unique
 //! <b>Remarks</b>: This comparison shall induce a
 //!   strict weak ordering betwen pointers.
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator<(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return x.get() < y.get();  }
 
 //! <b>Returns</b>: !(y < x).
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator<=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return !(y < x);  }
 
 //! <b>Returns</b>: y < x.
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator>(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return y < x;  }
 
 //! <b>Returns</b>:!(x < y).
 //!
 template <class T1, class D1, class T2, class D2>
-BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
+inline bool operator>=(const unique_ptr<T1, D1> &x, const unique_ptr<T2, D2> &y)
 {  return !(x < y);  }
 
 //! <b>Returns</b>:!x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator==(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+inline bool operator==(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>:!x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator==(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
+inline bool operator==(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
 {  return !x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator!=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
+inline bool operator!=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type)) BOOST_NOEXCEPT
 {  return !!x;  }
 
 //! <b>Returns</b>: (bool)x.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator!=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
+inline bool operator!=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x) BOOST_NOEXCEPT
 {  return !!x;  }
 
 //! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values.
 //!
 //! <b>Returns</b>: Returns <tt>x.get() < pointer()</tt>.
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator<(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return x.get() < typename unique_ptr<T, D>::pointer();  }
 
 //! <b>Requires</b>: <tt>operator </tt> shall induce a strict weak ordering on unique_ptr<T, D>::pointer values.
 //!
 //! <b>Returns</b>: Returns <tt>pointer() < x.get()</tt>.
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator<(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return typename unique_ptr<T, D>::pointer() < x.get();  }
 
 //! <b>Returns</b>: <tt>nullptr < x</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator>(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return x.get() > typename unique_ptr<T, D>::pointer();  }
 
 //! <b>Returns</b>: <tt>x < nullptr</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator>(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return typename unique_ptr<T, D>::pointer() > x.get();  }
 
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator<=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return !(bmupd::nullptr_type() < x);  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator<=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator<=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return !(x < bmupd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(x < nullptr)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
+inline bool operator>=(const unique_ptr<T, D> &x, BOOST_MOVE_DOC0PTR(bmupd::nullptr_type))
 {  return !(x < bmupd::nullptr_type());  }
 
 //! <b>Returns</b>: <tt>!(nullptr < x)</tt>.
 //!
 template <class T, class D>
-BOOST_MOVE_FORCEINLINE bool operator>=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
+inline bool operator>=(BOOST_MOVE_DOC0PTR(bmupd::nullptr_type), const unique_ptr<T, D> &x)
 {  return !(bmupd::nullptr_type() < x);  }
 
 }  //namespace movelib {
diff --git a/contrib/restricted/boost/move/ya.make b/contrib/restricted/boost/move/ya.make
index 1612adde42..a78230607b 100644
--- a/contrib/restricted/boost/move/ya.make
+++ b/contrib/restricted/boost/move/ya.make
@@ -9,9 +9,9 @@ LICENSE(
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.84.0)
+VERSION(1.85.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/move/archive/boost-1.84.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/move/archive/boost-1.85.0.tar.gz)
 
 PEERDIR(
     contrib/restricted/boost/config