Update contrib/restricted/boost/mp11 to 1.83.0

18 files changed, 717 insertions, 132 deletions

diff --git a/contrib/restricted/boost/mp11/README.md b/contrib/restricted/boost/mp11/README.md
index e24b9201151..b402344debc 100644
--- a/contrib/restricted/boost/mp11/README.md
+++ b/contrib/restricted/boost/mp11/README.md
@@ -14,7 +14,7 @@ instance. For CMake users, `add_subdirectory` is supported, as is installation a
 
 * g++ 4.8 or later
 * clang++ 3.9 or later
-* Visual Studio 2013, 2015, 2017, 2019
+* Visual Studio 2013 or later
 
 Tested on [Github Actions](https://github.com/boostorg/mp11/actions) and [Appveyor](https://ci.appveyor.com/project/pdimov/mp11/).
 
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp
index 60987a81db0..be377f5a6c7 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp
@@ -199,7 +199,10 @@ template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_imp
 namespace detail
 {
 
-template<class L, class V> struct mp_fill_impl;
+template<class L, class V> struct mp_fill_impl
+{
+// An error "no type named 'type'" here means that the L argument of mp_fill is not a list
+};
 
 template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
 {
@@ -216,6 +219,15 @@ template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<
 #endif
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, class V> struct mp_fill_impl<L<A...>, V>
+{
+    using type = L<((void)A, V::value)...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;
@@ -297,35 +309,35 @@ template<template<class...> class L, class... T, template<class...> class L2, cl
 {
     template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
 
-    using R = decltype( f( (mp_identity<T>*)0 ... ) );
+    using R = decltype( f( static_cast<mp_identity<T>*>(0) ... ) );
 
     using type = typename R::type;
 };
 
 } // namespace detail
 
-template<class L, std::size_t N> using mp_drop_c = typename detail::mp_drop_impl<L, mp_repeat_c<mp_list<void>, N>, mp_bool<N <= mp_size<L>::value>>::type;
+template<class L, std::size_t N> using mp_drop_c = mp_assign<L, typename detail::mp_drop_impl<mp_rename<L, mp_list>, mp_repeat_c<mp_list<void>, N>, mp_bool<N <= mp_size<L>::value>>::type>;
 
 template<class L, class N> using mp_drop = mp_drop_c<L, std::size_t{ N::value }>;
 
-// mp_from_sequence<S>
+// mp_from_sequence<S, F>
 namespace detail
 {
 
-template<class S> struct mp_from_sequence_impl;
+template<class S, class F> struct mp_from_sequence_impl;
 
-template<template<class T, T... I> class S, class U, U... J> struct mp_from_sequence_impl<S<U, J...>>
+template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F>
 {
-    using type = mp_list<std::integral_constant<U, J>...>;
+    using type = mp_list_c<U, (F::value + J)...>;
 };
 
 } // namespace detail
 
-template<class S> using mp_from_sequence = typename detail::mp_from_sequence_impl<S>::type;
+template<class S, class F = mp_int<0>> using mp_from_sequence = typename detail::mp_from_sequence_impl<S, F>::type;
 
-// mp_iota(_c)<N>
-template<std::size_t N> using mp_iota_c = mp_from_sequence<make_index_sequence<N>>;
-template<class N> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>>;
+// mp_iota(_c)<N, F>
+template<std::size_t N, std::size_t F = 0> using mp_iota_c = mp_from_sequence<make_index_sequence<N>, mp_size_t<F>>;
+template<class N, class F = mp_int<0>> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>, F>;
 
 // mp_at(_c)<L, I>
 namespace detail
@@ -340,11 +352,20 @@ template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_i
     using type = __type_pack_element<I, T...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, std::size_t I> struct mp_at_c_impl<L<A...>, I>
+{
+    using type = __type_pack_element<I, mp_value<A>...>;
+};
+
+#endif
+
 #else
 
 template<class L, std::size_t I> struct mp_at_c_impl
 {
-    using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, L>;
+    using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, mp_rename<L, mp_list>>;
     using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
 };
 
@@ -449,8 +470,8 @@ struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typen
 
 } // namespace detail
 
-template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<N, L>::type;
-template<class L, class N> using mp_take = typename detail::mp_take_c_impl<std::size_t{ N::value }, L>::type;
+template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
+template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;
 
 // mp_back<L>
 template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp
index 764bd598daa..44686c73e9a 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp
@@ -123,6 +123,17 @@
 # endif
 #endif
 
+// BOOST_MP11_HAS_TEMPLATE_AUTO
+
+#if defined(__cpp_nontype_template_parameter_auto) && __cpp_nontype_template_parameter_auto >= 201606L
+# define BOOST_MP11_HAS_TEMPLATE_AUTO
+#endif
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+// mp_value<0> is bool, mp_value<-1L> is int, etc
+# undef BOOST_MP11_HAS_TEMPLATE_AUTO
+#endif
+
 // BOOST_MP11_DEPRECATED(msg)
 
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_CLANG, < 304 )
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp
index 937d15ebe46..858ee24e6c4 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp
@@ -8,7 +8,10 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/mp11/detail/mp_count.hpp>
+#include <boost/mp11/detail/mp_is_value_list.hpp>
 #include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_list_v.hpp>
 #include <boost/mp11/utility.hpp>
 #include <boost/mp11/detail/config.hpp>
 
@@ -22,6 +25,8 @@ namespace mp11
 namespace detail
 {
 
+// append_type_lists
+
 template<class... L> struct mp_append_impl;
 
 #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
@@ -167,17 +172,148 @@ template<class... L> struct mp_append_impl: mp_append_impl_cuda_workaround<L...>
 
 #else
 
-template<class... L> struct mp_append_impl: mp_if_c<(sizeof...(L) > 111), mp_quote<append_inf_impl>, mp_if_c<(sizeof...(L) > 11), mp_quote<append_111_impl>, mp_quote<append_11_impl> > >::template fn<L...>
+template<class... L> struct mp_append_impl:
+    mp_cond<
+        mp_bool<(sizeof...(L) > 111)>, mp_quote<append_inf_impl>,
+        mp_bool<(sizeof...(L) > 11)>, mp_quote<append_111_impl>,
+        mp_true, mp_quote<append_11_impl>
+    >::template fn<L...>
 {
 };
 
-#endif
+#endif // #if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
 
-#endif
+#endif // #if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+struct append_type_lists
+{
+    template<class... L> using fn = typename mp_append_impl<L...>::type;
+};
+
+// append_value_lists
+
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<class... L> struct append_value_impl;
+
+template<class L1 = mp_list_v<>, class L2 = mp_list_v<>, class L3 = mp_list_v<>, class L4 = mp_list_v<>, class L5 = mp_list_v<>, class L6 = mp_list_v<>, class L7 = mp_list_v<>, class L8 = mp_list_v<>, class L9 = mp_list_v<>, class L10 = mp_list_v<>, class L11 = mp_list_v<>> struct append_value_11_impl
+{
+};
+
+template<
+    template<auto...> class L1, auto... T1,
+    template<auto...> class L2, auto... T2,
+    template<auto...> class L3, auto... T3,
+    template<auto...> class L4, auto... T4,
+    template<auto...> class L5, auto... T5,
+    template<auto...> class L6, auto... T6,
+    template<auto...> class L7, auto... T7,
+    template<auto...> class L8, auto... T8,
+    template<auto...> class L9, auto... T9,
+    template<auto...> class L10, auto... T10,
+    template<auto...> class L11, auto... T11>
+
+struct append_value_11_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, L6<T6...>, L7<T7...>, L8<T8...>, L9<T9...>, L10<T10...>, L11<T11...>>
+{
+    using type = L1<T1..., T2..., T3..., T4..., T5..., T6..., T7..., T8..., T9..., T10..., T11...>;
+};
+
+template<
+
+    class L00 = mp_list_v<>, class L01 = mp_list_v<>, class L02 = mp_list_v<>, class L03 = mp_list_v<>, class L04 = mp_list_v<>, class L05 = mp_list_v<>, class L06 = mp_list_v<>, class L07 = mp_list_v<>, class L08 = mp_list_v<>, class L09 = mp_list_v<>, class L0A = mp_list_v<>,
+    class L10 = mp_list_v<>, class L11 = mp_list_v<>, class L12 = mp_list_v<>, class L13 = mp_list_v<>, class L14 = mp_list_v<>, class L15 = mp_list_v<>, class L16 = mp_list_v<>, class L17 = mp_list_v<>, class L18 = mp_list_v<>, class L19 = mp_list_v<>,
+    class L20 = mp_list_v<>, class L21 = mp_list_v<>, class L22 = mp_list_v<>, class L23 = mp_list_v<>, class L24 = mp_list_v<>, class L25 = mp_list_v<>, class L26 = mp_list_v<>, class L27 = mp_list_v<>, class L28 = mp_list_v<>, class L29 = mp_list_v<>,
+    class L30 = mp_list_v<>, class L31 = mp_list_v<>, class L32 = mp_list_v<>, class L33 = mp_list_v<>, class L34 = mp_list_v<>, class L35 = mp_list_v<>, class L36 = mp_list_v<>, class L37 = mp_list_v<>, class L38 = mp_list_v<>, class L39 = mp_list_v<>,
+    class L40 = mp_list_v<>, class L41 = mp_list_v<>, class L42 = mp_list_v<>, class L43 = mp_list_v<>, class L44 = mp_list_v<>, class L45 = mp_list_v<>, class L46 = mp_list_v<>, class L47 = mp_list_v<>, class L48 = mp_list_v<>, class L49 = mp_list_v<>,
+    class L50 = mp_list_v<>, class L51 = mp_list_v<>, class L52 = mp_list_v<>, class L53 = mp_list_v<>, class L54 = mp_list_v<>, class L55 = mp_list_v<>, class L56 = mp_list_v<>, class L57 = mp_list_v<>, class L58 = mp_list_v<>, class L59 = mp_list_v<>,
+    class L60 = mp_list_v<>, class L61 = mp_list_v<>, class L62 = mp_list_v<>, class L63 = mp_list_v<>, class L64 = mp_list_v<>, class L65 = mp_list_v<>, class L66 = mp_list_v<>, class L67 = mp_list_v<>, class L68 = mp_list_v<>, class L69 = mp_list_v<>,
+    class L70 = mp_list_v<>, class L71 = mp_list_v<>, class L72 = mp_list_v<>, class L73 = mp_list_v<>, class L74 = mp_list_v<>, class L75 = mp_list_v<>, class L76 = mp_list_v<>, class L77 = mp_list_v<>, class L78 = mp_list_v<>, class L79 = mp_list_v<>,
+    class L80 = mp_list_v<>, class L81 = mp_list_v<>, class L82 = mp_list_v<>, class L83 = mp_list_v<>, class L84 = mp_list_v<>, class L85 = mp_list_v<>, class L86 = mp_list_v<>, class L87 = mp_list_v<>, class L88 = mp_list_v<>, class L89 = mp_list_v<>,
+    class L90 = mp_list_v<>, class L91 = mp_list_v<>, class L92 = mp_list_v<>, class L93 = mp_list_v<>, class L94 = mp_list_v<>, class L95 = mp_list_v<>, class L96 = mp_list_v<>, class L97 = mp_list_v<>, class L98 = mp_list_v<>, class L99 = mp_list_v<>,
+    class LA0 = mp_list_v<>, class LA1 = mp_list_v<>, class LA2 = mp_list_v<>, class LA3 = mp_list_v<>, class LA4 = mp_list_v<>, class LA5 = mp_list_v<>, class LA6 = mp_list_v<>, class LA7 = mp_list_v<>, class LA8 = mp_list_v<>, class LA9 = mp_list_v<>
+
+> struct append_value_111_impl
+{
+    using type = typename append_value_11_impl<
+
+        typename append_value_11_impl<L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A>::type,
+        typename append_value_11_impl<mp_list_v<>, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type,
+        typename append_value_11_impl<mp_list_v<>, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type,
+        typename append_value_11_impl<mp_list_v<>, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type,
+        typename append_value_11_impl<mp_list_v<>, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type,
+        typename append_value_11_impl<mp_list_v<>, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type,
+        typename append_value_11_impl<mp_list_v<>, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type,
+        typename append_value_11_impl<mp_list_v<>, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type,
+        typename append_value_11_impl<mp_list_v<>, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type,
+        typename append_value_11_impl<mp_list_v<>, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type,
+        typename append_value_11_impl<mp_list_v<>, LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9>::type
+
+    >::type;
+};
+
+template<
+
+    class L00, class L01, class L02, class L03, class L04, class L05, class L06, class L07, class L08, class L09, class L0A,
+    class L10, class L11, class L12, class L13, class L14, class L15, class L16, class L17, class L18, class L19,
+    class L20, class L21, class L22, class L23, class L24, class L25, class L26, class L27, class L28, class L29,
+    class L30, class L31, class L32, class L33, class L34, class L35, class L36, class L37, class L38, class L39,
+    class L40, class L41, class L42, class L43, class L44, class L45, class L46, class L47, class L48, class L49,
+    class L50, class L51, class L52, class L53, class L54, class L55, class L56, class L57, class L58, class L59,
+    class L60, class L61, class L62, class L63, class L64, class L65, class L66, class L67, class L68, class L69,
+    class L70, class L71, class L72, class L73, class L74, class L75, class L76, class L77, class L78, class L79,
+    class L80, class L81, class L82, class L83, class L84, class L85, class L86, class L87, class L88, class L89,
+    class L90, class L91, class L92, class L93, class L94, class L95, class L96, class L97, class L98, class L99,
+    class LA0, class LA1, class LA2, class LA3, class LA4, class LA5, class LA6, class LA7, class LA8, class LA9,
+    class... Lr
+
+> struct append_value_inf_impl
+{
+    using prefix = typename append_value_111_impl<
+
+        L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A,
+        L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
+        L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
+        L30, L31, L32, L33, L34, L35, L36, L37, L38, L39,
+        L40, L41, L42, L43, L44, L45, L46, L47, L48, L49,
+        L50, L51, L52, L53, L54, L55, L56, L57, L58, L59,
+        L60, L61, L62, L63, L64, L65, L66, L67, L68, L69,
+        L70, L71, L72, L73, L74, L75, L76, L77, L78, L79,
+        L80, L81, L82, L83, L84, L85, L86, L87, L88, L89,
+        L90, L91, L92, L93, L94, L95, L96, L97, L98, L99,
+        LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9
+
+    >::type;
+
+    using type = typename append_value_impl<prefix, Lr...>::type;
+};
+
+template<class... L> struct append_value_impl:
+    mp_cond<
+        mp_bool<(sizeof...(L) > 111)>, mp_quote<append_value_inf_impl>,
+        mp_bool<(sizeof...(L) > 11)>, mp_quote<append_value_111_impl>,
+        mp_true, mp_quote<append_value_11_impl>
+    >::template fn<L...>
+{
+};
+
+struct append_value_lists
+{
+    template<class... L> using fn = typename append_value_impl<L...>::type;
+};
+
+#endif // #if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
 
 } // namespace detail
 
-template<class... L> using mp_append = typename detail::mp_append_impl<L...>::type;
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<class... L> using mp_append = typename mp_if_c<(sizeof...(L) > 0 && sizeof...(L) == mp_count_if<mp_list<L...>, mp_is_value_list>::value), detail::append_value_lists, detail::append_type_lists>::template fn<L...>;
+
+#else
+
+template<class... L> using mp_append = detail::append_type_lists::fn<L...>;
+
+#endif
 
 } // namespace mp11
 } // namespace boost
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_defer.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_defer.hpp
new file mode 100644
index 00000000000..9aaca99ea0b
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_defer.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_MP11_DETAIL_MP_DEFER_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_DEFER_HPP_INCLUDED
+
+// Copyright 2015-2020, 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_if, mp_if_c
+namespace detail
+{
+
+template<bool C, class T, class... E> struct mp_if_c_impl
+{
+};
+
+template<class T, class... E> struct mp_if_c_impl<true, T, E...>
+{
+    using type = T;
+};
+
+template<class T, class E> struct mp_if_c_impl<false, T, E>
+{
+    using type = E;
+};
+
+} // namespace detail
+
+template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
+template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
+
+// mp_valid
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_INTEL, != 0 ) // tested at 1800
+
+// contributed by Roland Schulz in https://github.com/boostorg/mp11/issues/17
+
+namespace detail
+{
+
+template<class...> using void_t = void;
+
+template<class, template<class...> class F, class... T>
+struct mp_valid_impl: mp_false {};
+
+template<template<class...> class F, class... T>
+struct mp_valid_impl<void_t<F<T...>>, F, T...>: mp_true {};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<void, F, T...>;
+
+#else
+
+// implementation by Bruno Dutra (by the name is_evaluable)
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_valid_impl
+{
+    template<template<class...> class G, class = G<T...>> static mp_true check(int);
+    template<template<class...> class> static mp_false check(...);
+
+    using type = decltype(check<F>(0));
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;
+
+#endif
+
+template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;
+
+// mp_defer
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_defer_impl
+{
+    using type = F<T...>;
+};
+
+struct mp_no_type
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> struct mp_defer_cuda_workaround
+{
+    using type = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type;
+
+#else
+
+template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+
+#endif
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_DEFER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp
index 0745e876f65..266d9c18f0b 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp
@@ -9,6 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/mp11/detail/config.hpp>
+#include <boost/mp11/detail/mp_defer.hpp>
 
 namespace boost
 {
@@ -41,12 +42,113 @@ template<template<class...> class L, class V, template<class...> class F> struct
 
 #endif
 
-template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T...>, V, F>
+//
+
+template<class V, template<class...> class F> struct mp_fold_Q1
+{
+    template<class T1>
+        using fn = F<V, T1>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q2
+{
+    template<class T1, class T2>
+        using fn = F<F<V, T1>, T2>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q3
 {
-    using type = typename mp_fold_impl<L<T...>, F<V, T1>, F>::type;
+    template<class T1, class T2, class T3>
+        using fn = F<F<F<V, T1>, T2>, T3>;
 };
 
-template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
+template<class V, template<class...> class F> struct mp_fold_Q4
+{
+    template<class T1, class T2, class T3, class T4>
+        using fn = F<F<F<F<V, T1>, T2>, T3>, T4>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q5
+{
+    template<class T1, class T2, class T3, class T4, class T5>
+        using fn = F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q6
+{
+    template<class T1, class T2, class T3, class T4, class T5, class T6>
+        using fn = F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q7
+{
+    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+        using fn = F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q8
+{
+    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+        using fn = F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>;
+};
+
+template<class V, template<class...> class F> struct mp_fold_Q9
+{
+    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
+        using fn = F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
+};
+
+//
+
+template<template<class...> class L, class T1, class V, template<class...> class F>
+struct mp_fold_impl<L<T1>, V, F>: mp_defer<mp_fold_Q1<V, F>::template fn, T1>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2>, V, F>: mp_defer<mp_fold_Q2<V, F>::template fn, T1, T2>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3>, V, F>: mp_defer<mp_fold_Q3<V, F>::template fn, T1, T2, T3>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4>, V, F>: mp_defer<mp_fold_Q4<V, F>::template fn, T1, T2, T3, T4>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5>, V, F>: mp_defer<mp_fold_Q5<V, F>::template fn, T1, T2, T3, T4, T5>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6>, V, F>: mp_defer<mp_fold_Q6<V, F>::template fn, T1, T2, T3, T4, T5, T6>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7>, V, F>: mp_defer<mp_fold_Q7<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>, V, F>: mp_defer<mp_fold_Q8<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7, T8>
+{
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>, V, F>: mp_defer<mp_fold_Q9<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+{
+};
+
+//
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F>
+struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
 {
     using type = typename mp_fold_impl<L<T...>, F<F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>, T10>, F>::type;
 };
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp
index de83d0929b5..53a73ac3296 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp
@@ -1,13 +1,16 @@
 #ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
 #define BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
 
-//  Copyright 2015-2021 Peter Dimov.
+//  Copyright 2015-2023 Peter Dimov.
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/mp11/detail/mp_value.hpp>
+#include <boost/mp11/detail/config.hpp>
+
 namespace boost
 {
 namespace mp11
@@ -28,6 +31,15 @@ template<template<class...> class L, class T1, class... T> struct mp_front_impl<
     using type = T1;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A> struct mp_front_impl<L<A1, A...>>
+{
+    using type = mp_value<A1>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_front = typename detail::mp_front_impl<L>::type;
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_value_list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_value_list.hpp
new file mode 100644
index 00000000000..8f94f030cb0
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_value_list.hpp
@@ -0,0 +1,41 @@
+#ifndef BOOST_MP11_DETAIL_MP_IS_VALUE_LIST_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_IS_VALUE_LIST_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_is_value_list<L>
+namespace detail
+{
+
+template<class L> struct mp_is_value_list_impl
+{
+    using type = mp_false;
+};
+
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A> struct mp_is_value_list_impl<L<A...>>
+{
+    using type = mp_true;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L> using mp_is_value_list = typename detail::mp_is_value_list_impl<L>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_IS_VALUE_LIST_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list_v.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list_v.hpp
new file mode 100644
index 00000000000..bc05238a51b
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list_v.hpp
@@ -0,0 +1,27 @@
+#ifndef BOOST_MP11_DETAIL_MP_LIST_V_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_LIST_V_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+// mp_list_v<A...>
+template<auto... A> struct mp_list_v
+{
+};
+
+#endif
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_LIST_V_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp
index 5ba58a44f2f..2fb70d8e905 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp
@@ -74,7 +74,7 @@ template<template<class...> class M, class... T, class K> struct mp_map_find_imp
     template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
     static mp_identity<void> f( ... );
 
-    using type = mpmf_unwrap< decltype( f((U*)0) ) >;
+    using type = mpmf_unwrap< decltype( f( static_cast<U*>(0) ) ) >;
 };
 
 } // namespace detail
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp
index 90ed4c9d117..5c9417cd33e 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp
@@ -20,7 +20,10 @@ namespace mp11
 namespace detail
 {
 
-#if defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+#if defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, != 0 ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_CLANG, != 0 )
+
+// msvc fails with parser stack overflow for large sizeof...(T)
+// clang exceeds -fbracket-depth, which defaults to 256
 
 template<class... T> struct mp_plus_impl
 {
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp
index 8368ac68ad4..dde8f6f48e7 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp
@@ -1,13 +1,17 @@
 #ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
 #define BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
 
-//  Copyright 2015-2021 Peter Dimov.
+//  Copyright 2015-2023 Peter Dimov.
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/mp11/detail/mp_defer.hpp>
+#include <boost/mp11/detail/mp_value.hpp>
+#include <boost/mp11/detail/config.hpp>
+
 namespace boost
 {
 namespace mp11
@@ -17,22 +21,31 @@ namespace mp11
 namespace detail
 {
 
-template<class A, template<class...> class B> struct mp_rename_impl
+template<class L, template<class...> class B> struct mp_rename_impl
 {
 // An error "no type named 'type'" here means that the first argument to mp_rename is not a list
 };
 
-template<template<class...> class A, class... T, template<class...> class B> struct mp_rename_impl<A<T...>, B>
+template<template<class...> class L, class... T, template<class...> class B> struct mp_rename_impl<L<T...>, B>: mp_defer<B, T...>
+{
+};
+
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, template<class...> class B> struct mp_rename_impl<L<A...>, B>: mp_defer<B, mp_value<A>...>
 {
-    using type = B<T...>;
 };
 
+#endif
+
 } // namespace detail
 
-template<class A, template<class...> class B> using mp_rename = typename detail::mp_rename_impl<A, B>::type;
+template<class L, template<class...> class B> using mp_rename = typename detail::mp_rename_impl<L, B>::type;
 
+// mp_apply<F, L>
 template<template<class...> class F, class L> using mp_apply = typename detail::mp_rename_impl<L, F>::type;
 
+// mp_apply_q<Q, L>
 template<class Q, class L> using mp_apply_q = typename detail::mp_rename_impl<L, Q::template fn>::type;
 
 } // namespace mp11
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_value.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_value.hpp
new file mode 100644
index 00000000000..d0e598250bc
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_value.hpp
@@ -0,0 +1,25 @@
+#ifndef BOOST_MP11_DETAIL_MP_VALUE_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_VALUE_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+namespace boost
+{
+namespace mp11
+{
+
+template<auto A> using mp_value = std::integral_constant<decltype(A), A>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_VALUE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp
index 067167343c4..1b4fea3e2ba 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp
@@ -9,6 +9,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/mp11/version.hpp>
+#include <boost/mp11/detail/mp_value.hpp>
 #include <type_traits>
 #include <cstddef>
 
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp
index 6572a626972..364676445fb 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp
@@ -1,7 +1,7 @@
 #ifndef BOOST_MP11_LIST_HPP_INCLUDED
 #define BOOST_MP11_LIST_HPP_INCLUDED
 
-//  Copyright 2015-2017 Peter Dimov.
+//  Copyright 2015-2023 Peter Dimov.
 //
 //  Distributed under the Boost Software License, Version 1.0.
 //
@@ -10,10 +10,12 @@
 
 #include <boost/mp11/integral.hpp>
 #include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_list_v.hpp>
 #include <boost/mp11/detail/mp_is_list.hpp>
-#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_is_value_list.hpp>
 #include <boost/mp11/detail/mp_front.hpp>
 #include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
 #include <boost/mp11/detail/config.hpp>
 #include <type_traits>
 
@@ -22,12 +24,21 @@ namespace boost
 namespace mp11
 {
 
+// mp_list<T...>
+//   in detail/mp_list.hpp
+
 // mp_list_c<T, I...>
 template<class T, T... I> using mp_list_c = mp_list<std::integral_constant<T, I>...>;
 
+// mp_list_v<A...>
+//   in detail/mp_list_v.hpp
+
 // mp_is_list<L>
 //   in detail/mp_is_list.hpp
 
+// mp_is_value_list<L>
+//   in detail/mp_is_value_list.hpp
+
 // mp_size<L>
 namespace detail
 {
@@ -42,6 +53,15 @@ template<template<class...> class L, class... T> struct mp_size_impl<L<T...>>
     using type = mp_size_t<sizeof...(T)>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A> struct mp_size_impl<L<A...>>
+{
+    using type = mp_size_t<sizeof...(A)>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_size = typename detail::mp_size_impl<L>::type;
@@ -53,13 +73,35 @@ template<class L> using mp_empty = mp_bool< mp_size<L>::value == 0 >;
 namespace detail
 {
 
-template<class L1, class L2> struct mp_assign_impl;
+template<class L1, class L2> struct mp_assign_impl
+{
+// An error "no type named 'type'" here means that the arguments to mp_assign aren't lists
+};
 
 template<template<class...> class L1, class... T, template<class...> class L2, class... U> struct mp_assign_impl<L1<T...>, L2<U...>>
 {
     using type = L1<U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L1, auto... A, template<class...> class L2, class... U> struct mp_assign_impl<L1<A...>, L2<U...>>
+{
+    using type = L1<U::value...>;
+};
+
+template<template<class...> class L1, class... T, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<T...>, L2<B...>>
+{
+    using type = L1<mp_value<B>...>;
+};
+
+template<template<auto...> class L1, auto... A, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<A...>, L2<B...>>
+{
+    using type = L1<B...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L1, class L2> using mp_assign = typename detail::mp_assign_impl<L1, L2>::type;
@@ -85,6 +127,15 @@ template<template<class...> class L, class T1, class... T> struct mp_pop_front_i
     using type = L<T...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A> struct mp_pop_front_impl<L<A1, A...>>
+{
+    using type = L<A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_pop_front = typename detail::mp_pop_front_impl<L>::type;
@@ -110,6 +161,15 @@ template<template<class...> class L, class T1, class T2, class... T> struct mp_s
     using type = T2;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A> struct mp_second_impl<L<A1, A2, A...>>
+{
+    using type = mp_value<A2>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_second = typename detail::mp_second_impl<L>::type;
@@ -129,6 +189,15 @@ template<template<class...> class L, class T1, class T2, class T3, class... T> s
     using type = T3;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A> struct mp_third_impl<L<A1, A2, A3, A...>>
+{
+    using type = mp_value<A3>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L> using mp_third = typename detail::mp_third_impl<L>::type;
@@ -147,6 +216,15 @@ template<template<class...> class L, class... U, class... T> struct mp_push_fron
     using type = L<T..., U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, class... T> struct mp_push_front_impl<L<A...>, T...>
+{
+    using type = L<T::value..., A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class... T> using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;
@@ -165,6 +243,15 @@ template<template<class...> class L, class... U, class... T> struct mp_push_back
     using type = L<U..., T...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto... A, class... T> struct mp_push_back_impl<L<A...>, T...>
+{
+    using type = L<A..., T::value...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class... T> using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
@@ -174,6 +261,33 @@ template<class L, class... T> using mp_push_back = typename detail::mp_push_back
 // mp_apply_q<Q, L>
 //   in detail/mp_rename.hpp
 
+// mp_rename_v<L, B>
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+namespace detail
+{
+
+template<class L, template<auto...> class B> struct mp_rename_v_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_rename_v is not a list
+};
+
+template<template<class...> class L, class... T, template<auto...> class B> struct mp_rename_v_impl<L<T...>, B>
+{
+    using type = B<T::value...>;
+};
+
+template<template<auto...> class L, auto... A, template<auto...> class B> struct mp_rename_v_impl<L<A...>, B>
+{
+    using type = B<A...>;
+};
+
+} // namespace detail
+
+template<class L, template<auto...> class B> using mp_rename_v = typename detail::mp_rename_v_impl<L, B>::type;
+
+#endif
+
 // mp_replace_front<L, T>
 namespace detail
 {
@@ -189,6 +303,15 @@ template<template<class...> class L, class U1, class... U, class T> struct mp_re
     using type = L<T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A, class T> struct mp_replace_front_impl<L<A1, A...>, T>
+{
+    using type = L<T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;
@@ -211,6 +334,15 @@ template<template<class...> class L, class U1, class U2, class... U, class T> st
     using type = L<U1, T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A, class T> struct mp_replace_second_impl<L<A1, A2, A...>, T>
+{
+    using type = L<A1, T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;
@@ -230,6 +362,15 @@ template<template<class...> class L, class U1, class U2, class U3, class... U, c
     using type = L<U1, U2, T, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, class T> struct mp_replace_third_impl<L<A1, A2, A3, A...>, T>
+{
+    using type = L<A1, A2, T::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;
@@ -249,6 +390,15 @@ template<template<class...> class L, class U1, class... U, template<class...> cl
     using type = L<F<U1>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto... A, template<class...> class F> struct mp_transform_front_impl<L<A1, A...>, F>
+{
+    using type = L<F<mp_value<A1>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_front = typename detail::mp_transform_front_impl<L, F>::type;
@@ -273,6 +423,15 @@ template<template<class...> class L, class U1, class U2, class... U, template<cl
     using type = L<U1, F<U2>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto... A, template<class...> class F> struct mp_transform_second_impl<L<A1, A2, A...>, F>
+{
+    using type = L<A1, F<mp_value<A2>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_second = typename detail::mp_transform_second_impl<L, F>::type;
@@ -293,6 +452,15 @@ template<template<class...> class L, class U1, class U2, class U3, class... U, t
     using type = L<U1, U2, F<U3>, U...>;
 };
 
+#if defined(BOOST_MP11_HAS_TEMPLATE_AUTO)
+
+template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, template<class...> class F> struct mp_transform_third_impl<L<A1, A2, A3, A...>, F>
+{
+    using type = L<A1, A2, F<mp_value<A3>>::value, A...>;
+};
+
+#endif
+
 } // namespace detail
 
 template<class L, template<class...> class F> using mp_transform_third = typename detail::mp_transform_third_impl<L, F>::type;
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp
index fbab4a30f97..4010aee2e09 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp
@@ -13,6 +13,7 @@
 #include <boost/mp11/detail/mp_fold.hpp>
 #include <boost/mp11/detail/mp_front.hpp>
 #include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/mp_defer.hpp>
 #include <boost/mp11/detail/config.hpp>
 
 namespace boost
@@ -33,104 +34,9 @@ template<class T> using mp_identity_t = typename mp_identity<T>::type;
 template<class... T> struct mp_inherit: T... {};
 
 // mp_if, mp_if_c
-namespace detail
-{
-
-template<bool C, class T, class... E> struct mp_if_c_impl
-{
-};
-
-template<class T, class... E> struct mp_if_c_impl<true, T, E...>
-{
-    using type = T;
-};
-
-template<class T, class E> struct mp_if_c_impl<false, T, E>
-{
-    using type = E;
-};
-
-} // namespace detail
-
-template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
-template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
-
 // mp_valid
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_INTEL, != 0 ) // tested at 1800
-
-// contributed by Roland Schulz in https://github.com/boostorg/mp11/issues/17
-
-namespace detail
-{
-
-template<class...> using void_t = void;
-
-template<class, template<class...> class F, class... T>
-struct mp_valid_impl: mp_false {};
-
-template<template<class...> class F, class... T>
-struct mp_valid_impl<void_t<F<T...>>, F, T...>: mp_true {};
-
-} // namespace detail
-
-template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<void, F, T...>;
-
-#else
-
-// implementation by Bruno Dutra (by the name is_evaluable)
-namespace detail
-{
-
-template<template<class...> class F, class... T> struct mp_valid_impl
-{
-    template<template<class...> class G, class = G<T...>> static mp_true check(int);
-    template<template<class...> class> static mp_false check(...);
-
-    using type = decltype(check<F>(0));
-};
-
-} // namespace detail
-
-template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;
-
-#endif
-
-template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;
-
 // mp_defer
-namespace detail
-{
-
-template<template<class...> class F, class... T> struct mp_defer_impl
-{
-    using type = F<T...>;
-};
-
-struct mp_no_type
-{
-};
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
-
-template<template<class...> class F, class... T> struct mp_defer_cuda_workaround
-{
-    using type = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
-};
-
-#endif
-
-} // namespace detail
-
-#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
-
-template<template<class...> class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type;
-
-#else
-
-template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
-
-#endif
+//   moved to detail/mp_defer.hpp
 
 // mp_eval_if, mp_eval_if_c
 namespace detail
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp
index 318ca01d548..091266530b0 100644
--- a/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp
@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108200
+#define BOOST_MP11_VERSION 108300
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/ya.make b/contrib/restricted/boost/mp11/ya.make
index a8d127272f1..4b5bbf8f7b5 100644
--- a/contrib/restricted/boost/mp11/ya.make
+++ b/contrib/restricted/boost/mp11/ya.make
@@ -6,9 +6,9 @@ LICENSE(BSL-1.0)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
-VERSION(1.82.0)
+VERSION(1.83.0)
 
-ORIGINAL_SOURCE(https://github.com/boostorg/mp11/archive/boost-1.82.0.tar.gz)
+ORIGINAL_SOURCE(https://github.com/boostorg/mp11/archive/boost-1.83.0.tar.gz)
 
 ADDINCL(
     GLOBAL contrib/restricted/boost/mp11/include