passenger 6.0.19 → 6.0.20

data/src/cxx_supportlib/vendor-modified/boost/move/detail/type_traits.hpp

@@ -30,8 +30,7 @@
 // move/detail
 #include <boost/move/detail/meta_utils.hpp>
 // other
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
+#include <cassert>
 // std
 #include <cstddef>
 
@@ -1238,7 +1237,7 @@ struct aligned_next;
 template<std::size_t Len, std::size_t Align, class T>
 struct aligned_next<Len, Align, T, true>
 {
-   BOOST_STATIC_ASSERT((alignment_of<T>::value == Align));
+   BOOST_MOVE_STATIC_ASSERT((alignment_of<T>::value == Align));
    typedef aligned_union<T, Len> type;
 };
 
@@ -1278,13 +1277,13 @@ template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
 struct aligned_storage
 {
    //Sanity checks for input parameters
-   BOOST_STATIC_ASSERT(Align > 0);
+   BOOST_MOVE_STATIC_ASSERT(Align > 0);
 
    //Sanity checks for output type
    typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
    static const std::size_t value = alignment_of<type>::value;
-   BOOST_STATIC_ASSERT(value >= Align);
-   BOOST_STATIC_ASSERT((value % Align) == 0);
+   BOOST_MOVE_STATIC_ASSERT(value >= Align);
+   BOOST_MOVE_STATIC_ASSERT((value % Align) == 0);
 
    //Just in case someone instantiates aligned_storage
    //instead of aligned_storage::type (typical error).

data/src/cxx_supportlib/vendor-modified/boost/move/detail/workaround.hpp

@@ -68,4 +68,81 @@
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
 #endif
 
+namespace boost {
+namespace movelib {
+
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore(T1 const&)
+{}
+
+}} //namespace boost::movelib {
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_MOVE_TRY { try
+#    define BOOST_MOVE_CATCH(x) catch(x)
+#    define BOOST_MOVE_RETHROW throw;
+#    define BOOST_MOVE_CATCH_END }
+#else
+#    if !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+#        define BOOST_MOVE_TRY { if (true)
+#        define BOOST_MOVE_CATCH(x) else if (false)
+#    else
+// warning C4127: conditional expression is constant
+#        define BOOST_MOVE_TRY { \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (true) \
+             __pragma(warning(pop))
+#        define BOOST_MOVE_CATCH(x) else \
+             __pragma(warning(push)) \
+             __pragma(warning(disable: 4127)) \
+             if (false) \
+             __pragma(warning(pop))
+#    endif
+#    define BOOST_MOVE_RETHROW
+#    define BOOST_MOVE_CATCH_END }
+#endif
+
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+#  ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+#     define BOOST_MOVE_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__)
+#  else
+#     define BOOST_MOVE_STATIC_ASSERT( B ) static_assert(B, #B)
+#  endif
+#else
+namespace boost {
+namespace move_detail {
+
+template<bool B>
+struct STATIC_ASSERTION_FAILURE;
+
+template<>
+struct STATIC_ASSERTION_FAILURE<true>{};
+
+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
+
+#endif
+
+#if !defined(__has_cpp_attribute) || defined(__CUDACC__)
+#define BOOST_MOVE_HAS_MSVC_ATTRIBUTE(ATTR) 0
+#else
+#define BOOST_MOVE_HAS_MSVC_ATTRIBUTE(ATTR) __has_cpp_attribute(msvc::ATTR)
+#endif
+
+// See https://devblogs.microsoft.com/cppblog/improving-the-state-of-debug-performance-in-c/
+// for details on how MSVC has improved debug experience, specifically for move/forward-like utilities
+#if BOOST_MOVE_HAS_MSVC_ATTRIBUTE(intrinsic)
+#define BOOST_MOVE_INTRINSIC_CAST [[msvc::intrinsic]]
+#else
+#define BOOST_MOVE_INTRINSIC_CAST BOOST_MOVE_FORCEINLINE
+#endif
+
 #endif   //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+

data/src/cxx_supportlib/vendor-modified/boost/move/unique_ptr.hpp

@@ -25,8 +25,7 @@
 #include <boost/move/default_delete.hpp>
 #include <boost/move/utility_core.hpp>
 #include <boost/move/adl_move_swap.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/assert.hpp>
+#include <cassert>
 
 #include <cstddef>   //For std::nullptr_t and std::size_t
 
@@ -394,8 +393,8 @@ class unique_ptr
    {
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
    }
 
    //! <b>Effects</b>: Same as <tt>unique_ptr()</tt> (default constructor).
@@ -405,8 +404,8 @@ class unique_ptr
    {
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
    }
 
    //! <b>Requires</b>: D shall satisfy the requirements of DefaultConstructible, and
@@ -430,12 +429,12 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
       //If this constructor is instantiated with a pointer type or reference type
       //for the template argument D, the program is ill-formed.
-      BOOST_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
-      BOOST_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_pointer<D>::value);
+      BOOST_MOVE_STATIC_ASSERT(!bmupmu::is_reference<D>::value);
    }
 
    //!The signature of this constructor depends upon whether D is a reference type.
@@ -468,7 +467,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
    }
 
@@ -506,7 +505,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
    }
 
@@ -553,7 +552,7 @@ class unique_ptr
    {
       //If T is not an array type, U derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename unique_ptr<U, E>::pointer>::value ));
    }
 
@@ -620,7 +619,7 @@ class unique_ptr
    BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
       operator*() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!bmupmu::is_array<T>::value));
+      BOOST_MOVE_STATIC_ASSERT((!bmupmu::is_array<T>::value));
       return *m_data.m_p;
    }
 
@@ -632,8 +631,8 @@ class unique_ptr
    BOOST_MOVE_FORCEINLINE BOOST_MOVE_DOC1ST(element_type&, typename bmupmu::add_lvalue_reference<element_type>::type)
       operator[](std::size_t i) const BOOST_NOEXCEPT
    {
-      BOOST_ASSERT( bmupmu::extent<T>::value == 0 || i < bmupmu::extent<T>::value );
-      BOOST_ASSERT(m_data.m_p);
+      assert( bmupmu::extent<T>::value == 0 || i < bmupmu::extent<T>::value );
+      assert(m_data.m_p);
       return m_data.m_p[i];
    }
 
@@ -646,8 +645,8 @@ class unique_ptr
    //! <b>Remarks</b: If T is an array type, the program is ill-formed.
    BOOST_MOVE_FORCEINLINE pointer operator->() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!bmupmu::is_array<T>::value));
-      BOOST_ASSERT(m_data.m_p);
+      BOOST_MOVE_STATIC_ASSERT((!bmupmu::is_array<T>::value));
+      assert(m_data.m_p);
       return m_data.m_p;
    }
 
@@ -711,7 +710,7 @@ class unique_ptr
    {
       //If T is not an array type, element_type_t<Pointer> derives from T
       //it uses the default deleter and T has no virtual destructor, then you have a problem
-      BOOST_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
+      BOOST_MOVE_STATIC_ASSERT(( !bmupd::missing_virtual_destructor
                             <D, typename bmupd::get_element_type<Pointer>::type>::value ));
       pointer tmp = m_data.m_p;
       m_data.m_p = p;

data/src/cxx_supportlib/vendor-modified/boost/move/utility.hpp

@@ -126,13 +126,13 @@
       #else //BOOST_MOVE_DOXYGEN_INVOKED
 
          template <class T>
-         BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
+         BOOST_MOVE_INTRINSIC_CAST typename ::boost::move_detail::enable_if_c
             < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, T&&>::type
                move_if_noexcept(T& x) BOOST_NOEXCEPT
          {  return ::boost::move(x);   }
 
          template <class T>
-         BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c
+         BOOST_MOVE_INTRINSIC_CAST typename ::boost::move_detail::enable_if_c
             < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, const T&>::type
                move_if_noexcept(T& x) BOOST_NOEXCEPT
          {  return x;  }

data/src/cxx_supportlib/vendor-modified/boost/move/utility_core.hpp

@@ -29,7 +29,6 @@
 #include <boost/move/detail/workaround.hpp>  //forceinline
 #include <boost/move/core.hpp>
 #include <boost/move/detail/meta_utils.hpp>
-#include <boost/static_assert.hpp>
 
 #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_MOVE_DOXYGEN_INVOKED)
 
@@ -209,7 +208,8 @@
       #else //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
 
          template <class T>
-         BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
+         BOOST_MOVE_INTRINSIC_CAST
+         typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) BOOST_NOEXCEPT
          { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); }
 
       #endif   //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
@@ -245,14 +245,16 @@
       #else //Old move
 
          template <class T>
-         BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
+         BOOST_MOVE_INTRINSIC_CAST
+         T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) BOOST_NOEXCEPT
          {  return static_cast<T&&>(t);   }
 
          template <class T>
-         BOOST_MOVE_FORCEINLINE T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
+         BOOST_MOVE_INTRINSIC_CAST
+         T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
          {
             //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
-            BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
+            BOOST_MOVE_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
             return static_cast<T&&>(t);
          }
 
@@ -292,7 +294,7 @@
       BOOST_MOVE_FORCEINLINE T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) BOOST_NOEXCEPT
       {
          //"boost::forward<T> error: 'T' is a lvalue reference, can't forward as rvalue.";
-         BOOST_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
+         BOOST_MOVE_STATIC_ASSERT(!boost::move_detail::is_lvalue_reference<T>::value);
          return static_cast<T&&>(t);
       }
 

data/src/cxx_supportlib/vendor-modified/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;
@@ -291,41 +303,41 @@ template<class Q, class... L> using mp_product_q = typename detail::mp_product_i
 namespace detail
 {
 
-template<class L, class L2> struct mp_drop_impl;
+template<class L, class L2, class En> struct mp_drop_impl;
 
-template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>>
+template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
 {
     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>>::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 = typename detail::mp_drop_impl<L, mp_repeat<mp_list<void>, N>>::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>;

data/src/cxx_supportlib/vendor-modified/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 )

data/src/cxx_supportlib/vendor-modified/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