Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

177 files changed, 10984 insertions, 0 deletions

diff --git a/src/boost/libs/mp11/test/CMakeLists.txt b/src/boost/libs/mp11/test/CMakeLists.txt
new file mode 100644
index 000000000..cab19b651
--- /dev/null
+++ b/src/boost/libs/mp11/test/CMakeLists.txt
@@ -0,0 +1,12 @@
+# Copyright 2018 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(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(HAVE_BOOST_TEST)
+
+boost_test_jamfile(FILE Jamfile LINK_LIBRARIES Boost::mp11 Boost::core)
+boost_test(SOURCES check_cmake_version.cpp ARGUMENTS ${PROJECT_VERSION} LINK_LIBRARIES Boost::core Boost::config)
+
+endif()
diff --git a/src/boost/libs/mp11/test/Jamfile b/src/boost/libs/mp11/test/Jamfile
new file mode 100644
index 000000000..dc2d062c3
--- /dev/null
+++ b/src/boost/libs/mp11/test/Jamfile
@@ -0,0 +1,223 @@
+#  Boost.Mp11 Library Test Jamfile
+#
+#  Copyright 2015-2019 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
+
+import testing ;
+import ../../config/checks/config : requires ;
+
+project
+  : requirements
+
+    [ requires cxx11_variadic_templates cxx11_template_aliases cxx11_decltype cxx11_hdr_tuple ]
+
+    <toolset>msvc:<warnings>all # /W4
+    <toolset>msvc:<warnings-as-errors>on
+
+    <toolset>gcc:<warnings-as-errors>on
+
+    <toolset>clang:<warnings-as-errors>on
+  ;
+
+# include-only
+compile mp11.cpp ;
+
+# list
+run mp_size.cpp ;
+run mp_empty.cpp ;
+run mp_front.cpp ;
+run mp_pop_front.cpp ;
+run mp_second.cpp ;
+run mp_third.cpp ;
+run mp_push_front.cpp ;
+run mp_push_back.cpp ;
+run mp_rename.cpp ;
+run mp_append.cpp ;
+run mp_append_2.cpp ;
+run mp_append_sf.cpp ;
+run mp_replace_front.cpp ;
+run mp_replace_second.cpp ;
+run mp_replace_third.cpp ;
+run mp_apply_q.cpp ;
+run mp_is_list.cpp ;
+run mp_list_c.cpp ;
+run mp_transform_front.cpp ;
+run mp_transform_second.cpp ;
+run mp_transform_third.cpp ;
+
+# algorithm
+run mp_assign.cpp ;
+run mp_clear.cpp ;
+run mp_transform.cpp ;
+run mp_transform_q.cpp ;
+run mp_transform_sf.cpp ;
+run mp_transform_if.cpp ;
+run mp_transform_if_q.cpp ;
+run mp_filter.cpp ;
+run mp_fill.cpp ;
+run mp_count.cpp ;
+run mp_count_if.cpp ;
+run mp_count_if_q.cpp ;
+run mp_contains.cpp ;
+run mp_starts_with.cpp ;
+run mp_starts_with_sf.cpp ;
+run mp_repeat.cpp ;
+run mp_product.cpp ;
+run mp_drop.cpp ;
+run mp_iota.cpp ;
+run mp_at.cpp ;
+run mp_at_sf.cpp ;
+run mp_take.cpp ;
+run mp_replace.cpp ;
+run mp_replace_if.cpp ;
+run mp_replace_if_q.cpp ;
+run mp_copy_if.cpp ;
+run mp_copy_if_q.cpp ;
+run mp_remove.cpp ;
+run mp_remove_if.cpp ;
+run mp_remove_if_q.cpp ;
+run mp_partition.cpp ;
+run mp_partition_q.cpp ;
+run mp_sort.cpp ;
+run mp_sort_q.cpp ;
+run mp_find.cpp ;
+run mp_find_if.cpp ;
+run mp_find_if_q.cpp ;
+run mp_reverse.cpp ;
+run mp_fold.cpp ;
+run mp_fold_q.cpp ;
+run mp_reverse_fold.cpp ;
+run mp_reverse_fold_q.cpp ;
+run mp_unique.cpp ;
+run mp_unique_if.cpp ;
+run mp_unique_if_q.cpp ;
+run mp_all_of.cpp ;
+run mp_all_of_q.cpp ;
+run mp_any_of.cpp ;
+run mp_any_of_q.cpp ;
+run mp_none_of.cpp ;
+run mp_none_of_q.cpp ;
+run mp_replace_at.cpp ;
+run mp_replace_at_c.cpp ;
+run mp_for_each.cpp ;
+run mp_insert.cpp ;
+run mp_erase.cpp ;
+run mp_with_index.cpp ;
+run mp_with_index_cx.cpp ;
+run mp_from_sequence.cpp ;
+run mp_min_element.cpp ;
+run mp_min_element_q.cpp ;
+run mp_max_element.cpp ;
+run mp_max_element_q.cpp ;
+run mp_nth_element.cpp ;
+run mp_nth_element_q.cpp ;
+run mp_back.cpp ;
+run mp_pop_back.cpp ;
+run mp_flatten.cpp ;
+run mp_rotate_left.cpp ;
+run mp_rotate_right.cpp ;
+run mp_power_set.cpp ;
+run mp_partial_sum.cpp ;
+run mp_iterate.cpp ;
+
+# integral
+run integral.cpp ;
+
+# utility
+run mp_identity.cpp ;
+run mp_inherit.cpp ;
+run mp_if.cpp ;
+run mp_if_sf.cpp ;
+run mp_eval_if.cpp ;
+run mp_eval_if_sf.cpp ;
+run mp_valid.cpp ;
+run mp_defer.cpp ;
+run mp_quote.cpp ;
+run mp_invoke_q.cpp ;
+run mp_invoke_q_sf.cpp ;
+run mp_quote_trait.cpp ;
+run mp_cond.cpp ;
+run mp_cond_sf.cpp ;
+run mp_not_fn.cpp ;
+run mp_eval_if_not.cpp ;
+run mp_eval_or.cpp ;
+run mp_compose.cpp ;
+
+# integer_sequence
+run integer_sequence.cpp ;
+
+# tuple
+run tuple_for_each.cpp ;
+compile tuple_for_each_cx.cpp ;
+run tuple_apply.cpp ;
+compile tuple_apply_cx.cpp ;
+run construct_from_tuple.cpp ;
+compile construct_from_tuple_cx.cpp ;
+
+# set
+run mp_set_contains.cpp ;
+run mp_set_push_back.cpp ;
+run mp_set_push_front.cpp ;
+run mp_is_set.cpp ;
+run mp_set_union.cpp ;
+run mp_set_union_sf.cpp ;
+run mp_set_difference.cpp ;
+run mp_set_difference_sf.cpp ;
+run mp_set_intersection.cpp ;
+run mp_set_intersection_sf.cpp ;
+
+# function
+run mp_all.cpp ;
+run mp_and.cpp ;
+run mp_any.cpp ;
+run mp_or.cpp ;
+run mp_same.cpp ;
+run mp_plus.cpp ;
+run mp_less.cpp ;
+run mp_min.cpp ;
+run mp_max.cpp ;
+run mp_similar.cpp ;
+
+# map
+run mp_map_find.cpp ;
+run mp_map_contains.cpp ;
+run mp_map_insert.cpp ;
+run mp_map_replace.cpp ;
+run mp_map_erase.cpp ;
+run mp_map_update.cpp ;
+run mp_map_update_q.cpp ;
+run mp_map_keys.cpp ;
+run mp_is_map.cpp ;
+
+# bind
+run mp_bind.cpp ;
+run mp_bind_q.cpp ;
+run mp_bind_front.cpp ;
+run mp_bind_back.cpp ;
+
+# mpl
+run mpl.cpp : ;
+run mpl_list.cpp : ;
+run mpl_tuple.cpp : ;
+
+# version
+run version.cpp ;
+run mp11_version.cpp ;
+run list_version.cpp ;
+run algorithm_version.cpp ;
+run integral_version.cpp ;
+run utility_version.cpp ;
+run function_version.cpp ;
+run map_version.cpp ;
+run set_version.cpp ;
+run bind_version.cpp ;
+run integer_sequence_version.cpp ;
+run tuple_version.cpp ;
+run mpl_version.cpp ;
+
+# quick (for CI)
+alias quick : mp11 mp_size ;
+explicit quick ;
diff --git a/src/boost/libs/mp11/test/algorithm_version.cpp b/src/boost/libs/mp11/test/algorithm_version.cpp
new file mode 100644
index 000000000..6960803fa
--- /dev/null
+++ b/src/boost/libs/mp11/test/algorithm_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/algorithm.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/bind_version.cpp b/src/boost/libs/mp11/test/bind_version.cpp
new file mode 100644
index 000000000..75f3d9573
--- /dev/null
+++ b/src/boost/libs/mp11/test/bind_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/bind.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/check_cmake_version.cpp b/src/boost/libs/mp11/test/check_cmake_version.cpp
new file mode 100644
index 000000000..2fd464836
--- /dev/null
+++ b/src/boost/libs/mp11/test/check_cmake_version.cpp
@@ -0,0 +1,27 @@
+// Check whether the version in CMakeLists.txt is up to date
+//
+// Copyright 2018 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/core/lightweight_test.hpp>
+#include <boost/version.hpp>
+#include <cstdio>
+
+int main( int ac, char const* av[] )
+{
+    BOOST_TEST_EQ( ac, 2 );
+
+    if( ac >= 2 )
+    {
+        char version[ 64 ];
+        std::sprintf( version, "%d.%d.%d", BOOST_VERSION / 100000, BOOST_VERSION / 100 % 1000, BOOST_VERSION % 100 );
+
+        BOOST_TEST_CSTR_EQ( av[1], version );
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/cmake_install_test/CMakeLists.txt b/src/boost/libs/mp11/test/cmake_install_test/CMakeLists.txt
new file mode 100644
index 000000000..6dfc020df
--- /dev/null
+++ b/src/boost/libs/mp11/test/cmake_install_test/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright 2018 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_install_test LANGUAGES CXX)
+
+find_package(boost_mp11 REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::mp11)
+
+enable_testing()
+add_test(NAME main COMMAND main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
diff --git a/src/boost/libs/mp11/test/cmake_install_test/main.cpp b/src/boost/libs/mp11/test/cmake_install_test/main.cpp
new file mode 100644
index 000000000..7b8689ac6
--- /dev/null
+++ b/src/boost/libs/mp11/test/cmake_install_test/main.cpp
@@ -0,0 +1,12 @@
+// Copyright 2018 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.hpp>
+using namespace boost::mp11;
+
+int main()
+{
+    using L1 = mp_list<int, float, int, float>;
+    return mp_size<mp_unique<L1>>::value == 2? 0: 1;
+}
diff --git a/src/boost/libs/mp11/test/cmake_subdir_test/CMakeLists.txt b/src/boost/libs/mp11/test/cmake_subdir_test/CMakeLists.txt
new file mode 100644
index 000000000..6dd6975ae
--- /dev/null
+++ b/src/boost/libs/mp11/test/cmake_subdir_test/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Copyright 2018 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+add_subdirectory(../.. boostorg/mp11)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::mp11)
+
+enable_testing()
+add_test(NAME main COMMAND main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
diff --git a/src/boost/libs/mp11/test/cmake_subdir_test/main.cpp b/src/boost/libs/mp11/test/cmake_subdir_test/main.cpp
new file mode 100644
index 000000000..7b8689ac6
--- /dev/null
+++ b/src/boost/libs/mp11/test/cmake_subdir_test/main.cpp
@@ -0,0 +1,12 @@
+// Copyright 2018 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.hpp>
+using namespace boost::mp11;
+
+int main()
+{
+    using L1 = mp_list<int, float, int, float>;
+    return mp_size<mp_unique<L1>>::value == 2? 0: 1;
+}
diff --git a/src/boost/libs/mp11/test/construct_from_tuple.cpp b/src/boost/libs/mp11/test/construct_from_tuple.cpp
new file mode 100644
index 000000000..b4b7f34da
--- /dev/null
+++ b/src/boost/libs/mp11/test/construct_from_tuple.cpp
@@ -0,0 +1,222 @@
+
+// Copyright 2015, 2017 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <tuple>
+#include <memory>
+#include <utility>
+#include <array>
+
+struct T1
+{
+    int x, y, z;
+
+    T1( int x = 0, int y = 0, int z = 0 ): x(x), y(y), z(z) {}
+};
+
+struct T2
+{
+    std::unique_ptr<int> x, y, z;
+
+    T2( std::unique_ptr<int> x, std::unique_ptr<int> y, std::unique_ptr<int> z ): x(std::move(x)), y(std::move(y)), z(std::move(z)) {}
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+    T2( T2&& r ): x( std::move(r.x) ), y( std::move(r.y) ), z( std::move(r.z) ) {}
+
+#endif
+};
+
+int main()
+{
+    using boost::mp11::construct_from_tuple;
+
+    {
+        std::tuple<int, short, char> tp{ 1, 2, 3 };
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+    }
+
+    {
+        std::tuple<int, short, char> const tp{ 1, 2, 3 };
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 8
+#else
+
+    {
+        std::tuple<std::unique_ptr<int>, std::unique_ptr<int>, std::unique_ptr<int>> tp{ std::unique_ptr<int>(new int(1)), std::unique_ptr<int>(new int(2)), std::unique_ptr<int>(new int(3)) };
+
+            T2 t2 = construct_from_tuple<T2>( std::move(tp) );
+
+            BOOST_TEST_EQ( *t2.x, 1 );
+            BOOST_TEST_EQ( *t2.y, 2 );
+            BOOST_TEST_EQ( *t2.z, 3 );
+    }
+
+#endif
+
+    {
+        std::pair<int, short> tp{ 1, 2 };
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+    }
+
+    {
+        std::pair<int, short> const tp{ 1, 2 };
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+    }
+
+    {
+        std::array<int, 3> tp{{ 1, 2, 3 }};
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+    }
+
+    {
+        std::array<int, 3> const tp{{ 1, 2, 3 }};
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 1 );
+            BOOST_TEST_EQ( t1.y, 2 );
+            BOOST_TEST_EQ( t1.z, 3 );
+        }
+    }
+
+    {
+        std::tuple<> tp;
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 0 );
+            BOOST_TEST_EQ( t1.y, 0 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 0 );
+            BOOST_TEST_EQ( t1.y, 0 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+    }
+
+    {
+        std::array<int, 0> tp;
+
+        {
+            T1 t1 = construct_from_tuple<T1>( tp );
+
+            BOOST_TEST_EQ( t1.x, 0 );
+            BOOST_TEST_EQ( t1.y, 0 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+
+        {
+            T1 t1 = construct_from_tuple<T1>( std::move(tp) );
+
+            BOOST_TEST_EQ( t1.x, 0 );
+            BOOST_TEST_EQ( t1.y, 0 );
+            BOOST_TEST_EQ( t1.z, 0 );
+        }
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/construct_from_tuple_cx.cpp b/src/boost/libs/mp11/test/construct_from_tuple_cx.cpp
new file mode 100644
index 000000000..4820a8609
--- /dev/null
+++ b/src/boost/libs/mp11/test/construct_from_tuple_cx.cpp
@@ -0,0 +1,87 @@
+
+// Copyright 2015 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+// Technically std::tuple isn't constexpr enabled in C++11, but it works with libstdc++
+
+#if defined( BOOST_MP11_NO_CONSTEXPR ) || ( !defined( __GLIBCXX__ ) && __cplusplus < 201400L )
+
+int main() {}
+
+#else
+
+#include <tuple>
+#include <array>
+#include <utility>
+
+struct T1
+{
+    int x, y, z;
+
+    constexpr T1( int x = 0, int y = 0, int z = 0 ): x(x), y(y), z(z) {}
+};
+
+int main()
+{
+    using boost::mp11::construct_from_tuple;
+
+    {
+        constexpr std::tuple<int, short, char> tp{ 1, 2, 3 };
+
+        constexpr auto r = construct_from_tuple<T1>( tp );
+
+        static_assert( r.x == 1, "r.x == 1" );
+        static_assert( r.y == 2, "r.y == 2" );
+        static_assert( r.z == 3, "r.z == 3" );
+    }
+
+    {
+        constexpr std::pair<short, char> tp{ 1, 2 };
+
+        constexpr auto r = construct_from_tuple<T1>( tp );
+
+        static_assert( r.x == 1, "r.x == 1" );
+        static_assert( r.y == 2, "r.y == 2" );
+        static_assert( r.z == 0, "r.z == 0" );
+    }
+
+    {
+        constexpr std::array<short, 3> tp{{ 1, 2, 3 }};
+
+        constexpr auto r = construct_from_tuple<T1>( tp );
+
+        static_assert( r.x == 1, "r.x == 1" );
+        static_assert( r.y == 2, "r.y == 2" );
+        static_assert( r.z == 3, "r.z == 3" );
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 9
+// "error: default initialization of an object of const type 'const std::tuple<>' without a user-provided default constructor"
+#else
+
+    {
+        constexpr std::tuple<> tp;
+
+        constexpr auto r = construct_from_tuple<T1>( tp );
+
+        static_assert( r.x == 0, "r.x == 0" );
+        static_assert( r.y == 0, "r.y == 0" );
+        static_assert( r.z == 0, "r.z == 0" );
+    }
+
+#endif
+}
+
+#endif
diff --git a/src/boost/libs/mp11/test/function_version.cpp b/src/boost/libs/mp11/test/function_version.cpp
new file mode 100644
index 000000000..9464a827d
--- /dev/null
+++ b/src/boost/libs/mp11/test/function_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/function.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/integer_sequence.cpp b/src/boost/libs/mp11/test/integer_sequence.cpp
new file mode 100644
index 000000000..bc489ab67
--- /dev/null
+++ b/src/boost/libs/mp11/test/integer_sequence.cpp
@@ -0,0 +1,59 @@
+
+//  Copyright 2015 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/integer_sequence.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::integer_sequence;
+    using boost::mp11::make_integer_sequence;
+    using boost::mp11::index_sequence;
+    using boost::mp11::make_index_sequence;
+    using boost::mp11::index_sequence_for;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<int, 0>, integer_sequence<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<int, 1>, integer_sequence<int, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<int, 2>, integer_sequence<int, 0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<int, 3>, integer_sequence<int, 0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<int, 4>, integer_sequence<int, 0, 1, 2, 3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<char, 0>, integer_sequence<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<char, 1>, integer_sequence<char, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<char, 2>, integer_sequence<char, 0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<char, 3>, integer_sequence<char, 0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<char, 4>, integer_sequence<char, 0, 1, 2, 3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<std::size_t, 0>, integer_sequence<std::size_t>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<std::size_t, 1>, integer_sequence<std::size_t, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<std::size_t, 2>, integer_sequence<std::size_t, 0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<std::size_t, 3>, integer_sequence<std::size_t, 0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_integer_sequence<std::size_t, 4>, integer_sequence<std::size_t, 0, 1, 2, 3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<0>, integer_sequence<std::size_t>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<1>, integer_sequence<std::size_t, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<2>, integer_sequence<std::size_t, 0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<3>, integer_sequence<std::size_t, 0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<4>, integer_sequence<std::size_t, 0, 1, 2, 3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<0>, index_sequence<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<1>, index_sequence<0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<2>, index_sequence<0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<3>, index_sequence<0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<make_index_sequence<4>, index_sequence<0, 1, 2, 3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<index_sequence_for<>, index_sequence<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<index_sequence_for<void>, index_sequence<0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<index_sequence_for<void, void>, index_sequence<0, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<index_sequence_for<void, void, void>, index_sequence<0, 1, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<index_sequence_for<void, void, void, void>, index_sequence<0, 1, 2, 3>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/integer_sequence_version.cpp b/src/boost/libs/mp11/test/integer_sequence_version.cpp
new file mode 100644
index 000000000..2ba3ffe02
--- /dev/null
+++ b/src/boost/libs/mp11/test/integer_sequence_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/integer_sequence.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/integral.cpp b/src/boost/libs/mp11/test/integral.cpp
new file mode 100644
index 000000000..ce0f96106
--- /dev/null
+++ b/src/boost/libs/mp11/test/integral.cpp
@@ -0,0 +1,70 @@
+
+//  Copyright 2015 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/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <cstddef>
+
+int main()
+{
+    using boost::mp11::mp_bool;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bool<false>, std::integral_constant<bool, false>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bool<true>, std::integral_constant<bool, true>>));
+
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_false, std::integral_constant<bool, false>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_true, std::integral_constant<bool, true>>));
+
+    using boost::mp11::mp_int;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_int<0>, std::integral_constant<int, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_int<814>, std::integral_constant<int, 814>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_int<-144>, std::integral_constant<int, -144>>));
+
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size_t<0>, std::integral_constant<std::size_t, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size_t<1972>, std::integral_constant<std::size_t, 1972>>));
+
+    using boost::mp11::mp_to_bool;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_false>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_true>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_int<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_int<107>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_int<-1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_int<-91>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_size_t<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_size_t<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_to_bool<mp_size_t<442>>, mp_true>));
+
+    using boost::mp11::mp_not;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_false>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_true>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_int<0>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_int<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_int<107>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_int<-1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_int<-91>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_size_t<0>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_size_t<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_not<mp_size_t<442>>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/integral_version.cpp b/src/boost/libs/mp11/test/integral_version.cpp
new file mode 100644
index 000000000..2ba708069
--- /dev/null
+++ b/src/boost/libs/mp11/test/integral_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/integral.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/list_version.cpp b/src/boost/libs/mp11/test/list_version.cpp
new file mode 100644
index 000000000..9cee66409
--- /dev/null
+++ b/src/boost/libs/mp11/test/list_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/list.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/map_version.cpp b/src/boost/libs/mp11/test/map_version.cpp
new file mode 100644
index 000000000..92925f591
--- /dev/null
+++ b/src/boost/libs/mp11/test/map_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/map.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp11.cpp b/src/boost/libs/mp11/test/mp11.cpp
new file mode 100644
index 000000000..6ab26cb7a
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp11.cpp
@@ -0,0 +1,14 @@
+
+//  Copyright 2015 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.hpp>
+
+int main()
+{
+}
diff --git a/src/boost/libs/mp11/test/mp11_version.cpp b/src/boost/libs/mp11/test/mp11_version.cpp
new file mode 100644
index 000000000..17332664f
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp11_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_all.cpp b/src/boost/libs/mp11/test/mp_all.cpp
new file mode 100644
index 000000000..64f1e8f6a
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_all.cpp
@@ -0,0 +1,70 @@
+
+// Copyright 2015, 2016 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/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_all;
+
+template<class V, class... T> using check1 = mp_all<std::is_same<V, void>, std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>;
+template<class V, class... T> using check2 = mp_all<std::is_same<V, void>, mp_all<std::is_copy_constructible<T>..., mp_all<std::is_copy_assignable<T>...>>>;
+
+int main()
+{
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_int<-7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_size_t<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_false, mp_true>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_false>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_int<-7>, mp_int<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_size_t<(size_t)-1>, mp_size_t<1>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_false, mp_true>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_true, mp_false, mp_true, mp_true>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_false, mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_int<1>, mp_int<2>, mp_int<-11>, mp_int<14>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_int<1>, mp_int<0>, mp_int<-11>, mp_int<14>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_size_t<1>, mp_size_t<2>, mp_size_t<114>, mp_size_t<8>, mp_size_t<94>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all<mp_size_t<1>, mp_size_t<2>, mp_size_t<114>, mp_size_t<0>, mp_size_t<94>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<check1<void, int, float>, mp_true>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40900 )
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<check2<void, int, float>, mp_true>));
+
+#endif
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_all_of.cpp b/src/boost/libs/mp11/test/mp_all_of.cpp
new file mode 100644
index 000000000..6e01aec29
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_all_of.cpp
@@ -0,0 +1,57 @@
+
+// Copyright 2015, 2016 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_all_of;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L1, std::is_const>, mp_true>));
+
+        using L2 = mp_list<X1 const, X1 const, X1 const volatile, X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_const>, mp_true>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L1, std::is_const>, mp_true>));
+
+        using L2 = std::tuple<X1 const, X1 const, X1 const volatile, X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_const>, mp_true>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of<L2, std::is_const>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_all_of_q.cpp b/src/boost/libs/mp11/test/mp_all_of_q.cpp
new file mode 100644
index 000000000..8a877c552
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_all_of_q.cpp
@@ -0,0 +1,59 @@
+
+// Copyright 2015, 2016, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_all_of_q;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L1, mp_quote<std::is_const>>, mp_true>));
+
+        using L2 = mp_list<X1 const, X1 const, X1 const volatile, X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L1, mp_quote<std::is_const>>, mp_true>));
+
+        using L2 = std::tuple<X1 const, X1 const, X1 const volatile, X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1 const volatile>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_all_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_and.cpp b/src/boost/libs/mp11/test/mp_and.cpp
new file mode 100644
index 000000000..93da74a20
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_and.cpp
@@ -0,0 +1,64 @@
+
+// Copyright 2015-2017 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/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_and;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<-7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_false>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_false, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<-4>, mp_int<5>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<-4>, mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<0>, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<7>, mp_size_t<8>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<7>, mp_size_t<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<0>, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true, mp_false>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_false, void>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_false, void, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true, mp_true, mp_false>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_true, mp_false, void>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_true, mp_false, void, void>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_false, void, void, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<1>, mp_int<2>, mp_int<-11>, mp_int<14>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_int<1>, mp_int<0>, void, void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<1>, mp_size_t<2>, mp_size_t<114>, mp_size_t<8>, mp_size_t<94>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_and<mp_size_t<1>, mp_size_t<2>, mp_size_t<0>, void, void>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_any.cpp b/src/boost/libs/mp11/test/mp_any.cpp
new file mode 100644
index 000000000..9376050ef
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_any.cpp
@@ -0,0 +1,91 @@
+
+// Copyright 2015, 2016, 2019 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/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/set.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_any;
+using boost::mp11::mp_all;
+
+template<class... T> using check1 = mp_any<std::is_nothrow_copy_constructible<T>..., mp_any<std::is_nothrow_move_constructible<T>...>>;
+template<class... T> using check2 = mp_any<mp_any<std::is_nothrow_copy_constructible<T>...>, std::is_nothrow_move_constructible<T>...>;
+template<class... T> using check3 = mp_any<mp_all<std::is_nothrow_copy_constructible<T>...>, std::is_nothrow_default_constructible<T>...>;
+
+template<bool is_trivially_destructible, bool is_single_buffered, class... T> struct variant_base_impl {};
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+template<class... T> using variant_base = variant_base_impl<mp_all<std::has_trivial_destructor<T>...>::value, mp_any<mp_all<std::is_nothrow_move_constructible<T>...>, std::is_nothrow_default_constructible<T>...>::value, T...>;
+#else
+template<class... T> using variant_base = variant_base_impl<mp_all<std::is_trivially_destructible<T>...>::value, mp_any<mp_all<std::is_nothrow_move_constructible<T>...>, std::is_nothrow_default_constructible<T>...>::value, T...>;
+#endif
+
+using boost::mp11::mp_set_contains;
+
+template<class T, class... S> using in_any_set = mp_any< mp_set_contains<S, T>... >;
+
+int main()
+{
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<-7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_true, mp_false>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<-7>, mp_int<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<(size_t)-1>, mp_size_t<1>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_false, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_true, mp_true, mp_true, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_false, mp_true, mp_false>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_false, mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<1>, mp_int<2>, mp_int<-11>, mp_int<14>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<0>, mp_int<0>, mp_int<-11>, mp_int<0>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_int<0>, mp_int<0>, mp_int<0>, mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<1>, mp_size_t<2>, mp_size_t<114>, mp_size_t<8>, mp_size_t<94>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<0>, mp_size_t<0>, mp_size_t<114>, mp_size_t<0>, mp_size_t<0>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<0>, mp_size_t<0>, mp_size_t<0>, mp_size_t<0>, mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<0>, mp_int<0>, mp_false, mp_size_t<141>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any<mp_size_t<0>, mp_int<0>, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<check1<void, int, float>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<check2<void, int, float>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<check3<void, int, float>, mp_true>));
+
+    variant_base<void, int, float>();
+
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<in_any_set<void, mp_list<void>, mp_list<int>>, mp_true>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_any_of.cpp b/src/boost/libs/mp11/test/mp_any_of.cpp
new file mode 100644
index 000000000..e6aa3b186
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_any_of.cpp
@@ -0,0 +1,72 @@
+
+// Copyright 2015, 2016 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_any_of;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L1, std::is_const>, mp_false>));
+
+        using L2 = mp_list<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_const>, mp_true>));
+
+        using L3 = mp_list<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_const>, mp_true>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L1, std::is_const>, mp_false>));
+
+        using L2 = std::tuple<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_const>, mp_true>));
+
+        using L3 = std::tuple<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_const>, mp_true>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L2, std::is_const>, mp_true>));
+
+        using L3 = std::pair<X1 const, X1 const>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_volatile>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of<L3, std::is_const>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_any_of_q.cpp b/src/boost/libs/mp11/test/mp_any_of_q.cpp
new file mode 100644
index 000000000..17b50dcf0
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_any_of_q.cpp
@@ -0,0 +1,74 @@
+
+// Copyright 2015, 2016, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_any_of_q;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L1, mp_quote<std::is_const>>, mp_false>));
+
+        using L2 = mp_list<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+
+        using L3 = mp_list<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L1, mp_quote<std::is_const>>, mp_false>));
+
+        using L2 = std::tuple<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+
+        using L3 = std::tuple<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L2, mp_quote<std::is_const>>, mp_true>));
+
+        using L3 = std::pair<X1 const, X1 const>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_volatile>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_any_of_q<L3, mp_quote<std::is_const>>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_append.cpp b/src/boost/libs/mp11/test/mp_append.cpp
new file mode 100644
index 000000000..264359a17
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_append.cpp
@@ -0,0 +1,76 @@
+
+// Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+struct X6 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_append;
+
+    using L1 = mp_list<char[1], char[1]>;
+    using L2 = mp_list<char[2], char[2]>;
+    using L3 = mp_list<char[3], char[3]>;
+    using L4 = mp_list<char[4], char[4]>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<L1>, mp_list<char[1], char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<L1, L2>, mp_list<char[1], char[1], char[2], char[2]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<L1, L2, L3>, mp_list<char[1], char[1], char[2], char[2], char[3], char[3]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<L1, L2, L3, L4>, mp_list<char[1], char[1], char[2], char[2], char[3], char[3], char[4], char[4]>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>>, std::tuple<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>, std::tuple<X2>>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X3>>, std::tuple<X1, X2, X3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X3>, std::tuple<X4>>, std::tuple<X1, X2, X3, X4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X3>, std::tuple<X4>, std::tuple<X5>>, std::tuple<X1, X2, X3, X4, X5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X3>, std::tuple<X4>, std::tuple<X5>, std::tuple<X6>>, std::tuple<X1, X2, X3, X4, X5, X6>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>>, std::tuple<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>, std::tuple<X2>>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>, std::tuple<X2>, mp_list<X3>>, std::tuple<X1, X2, X3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>, std::tuple<X2>, mp_list<X3>, std::tuple<X4>>, std::tuple<X1, X2, X3, X4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>, std::tuple<X2>, mp_list<X3>, std::tuple<X4>, mp_list<X5>>, std::tuple<X1, X2, X3, X4, X5>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, mp_list<X1>, std::tuple<X2>, mp_list<X3>, std::tuple<X4>, mp_list<X5>, std::tuple<X6>>, std::tuple<X1, X2, X3, X4, X5, X6>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::pair<X1, X2>>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::pair<X1, X2>, std::pair<X3, X4>>, std::tuple<X1, X2, X3, X4>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::tuple<>, std::pair<X1, X2>, std::pair<X3, X4>, std::pair<X5, X6>>, std::tuple<X1, X2, X3, X4, X5, X6>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::pair<X1, X2>>, std::pair<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::pair<X1, X2>, mp_list<>>, std::pair<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::pair<X1, X2>, mp_list<>, mp_list<>>, std::pair<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::pair<X1, X2>, mp_list<>, mp_list<>, mp_list<>>, std::pair<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_append<std::pair<X1, X2>, mp_list<>, mp_list<>, mp_list<>, mp_list<>>, std::pair<X1, X2>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_append_2.cpp b/src/boost/libs/mp11/test/mp_append_2.cpp
new file mode 100644
index 000000000..4b3bebd4f
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_append_2.cpp
@@ -0,0 +1,38 @@
+
+//  Copyright 2015-2017 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+template<class T> struct W;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_append;
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_transform;
+    using boost::mp11::mp_rename;
+    using boost::mp11::mp_push_front;
+
+    using L1 = mp_iota_c<125>;
+    using L2 = mp_transform<W, L1>;
+    using L3 = mp_push_front<L2, mp_list<>>;
+    using L4 = mp_rename<L3, mp_append>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<L4, L1>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_append_sf.cpp b/src/boost/libs/mp11/test/mp_append_sf.cpp
new file mode 100644
index 000000000..80c417c10
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_append_sf.cpp
@@ -0,0 +1,32 @@
+
+// Copyright 2019 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/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    using boost::mp11::mp_append;
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, void, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, void, void, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, mp_list<>, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_append, mp_list<>, mp_list<>, mp_list<>, mp_list<>, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_apply_q.cpp b/src/boost/libs/mp11/test/mp_apply_q.cpp
new file mode 100644
index 000000000..d2a47c04b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_apply_q.cpp
@@ -0,0 +1,113 @@
+
+//  Copyright 2015-2017 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+template<class... T> struct X {};
+template<class... T> using Y = X<T...>;
+
+struct Q
+{
+    template<class... T> using fn = X<T...>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_quote;
+    using boost::mp11::mp_apply_q;
+
+    using L1 = mp_list<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L1>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L1>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L1>, Y<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L1>, X<>>));
+
+    using L2 = mp_list<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L2>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L2>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L2>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L2>, Y<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L2>, X<char>>));
+
+    using L3 = mp_list<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L3>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L3>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L3>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L3>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L3>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L3>, X<char, double>>));
+
+    using L4 = mp_list<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L4>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L4>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L4>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L4>, Y<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L4>, X<int, char, float>>));
+
+    //
+
+    using L5 = std::tuple<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L5>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L5>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L5>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L5>, Y<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L5>, X<>>));
+
+    using L6 = std::tuple<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L6>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L6>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L6>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L6>, Y<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L6>, X<char>>));
+
+    using L7 = std::tuple<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L7>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L7>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L7>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L7>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L7>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L7>, X<char, double>>));
+
+    using L8 = std::tuple<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L8>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L8>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L8>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L8>, Y<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L8>, X<int, char, float>>));
+
+    //
+
+    using L9 = std::pair<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<mp_list>, L9>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::tuple>, L9>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<X>, L9>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<Y>, L9>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<mp_quote<std::pair>, L9>, std::pair<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply_q<Q, L9>, X<char, double>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_assign.cpp b/src/boost/libs/mp11/test/mp_assign.cpp
new file mode 100644
index 000000000..60edd0cb3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_assign.cpp
@@ -0,0 +1,64 @@
+
+// Copyright 2015, 2017 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/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_assign;
+
+    using L1 = mp_list<int, void(), float[]>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, mp_list<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, mp_list<X1>>, mp_list<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, mp_list<X1, X2>>, mp_list<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, mp_list<X1, X2, X3>>, mp_list<X1, X2, X3>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, std::tuple<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, std::tuple<X1>>, mp_list<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, std::tuple<X1, X2>>, mp_list<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, std::tuple<X1, X2, X3>>, mp_list<X1, X2, X3>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L1, std::pair<X1, X2>>, mp_list<X1, X2>>));
+
+    //
+
+    using L2 = std::tuple<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L2, mp_list<>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L2, mp_list<X1>>, std::tuple<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L2, mp_list<X1, X2>>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L2, mp_list<X1, X2, X3>>, std::tuple<X1, X2, X3>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L2, std::pair<X1, X2>>, std::tuple<X1, X2>>));
+
+    //
+
+    using L3 = std::pair<int, char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L3, mp_list<X1, X2>>, std::pair<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_assign<L3, std::pair<X1, X2>>, std::pair<X1, X2>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_at.cpp b/src/boost/libs/mp11/test/mp_at.cpp
new file mode 100644
index 000000000..6ff3fd43b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_at.cpp
@@ -0,0 +1,74 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_at;
+    using boost::mp11::mp_at_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 0>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 1>, X2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 2>, X3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 3>, X4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 4>, X5>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<0>>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<1>>, X2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<2>>, X3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<3>>, X4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<4>>, X5>));
+    }
+
+    {
+        using L1 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 0>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 1>, X2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 2>, X3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 3>, X4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 4>, X5>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<0>>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<1>>, X2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<2>>, X3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<3>>, X4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<4>>, X5>));
+    }
+
+    {
+        using L1 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 0>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at_c<L1, 1>, X2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<0>>, X1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_at<L1, mp_size_t<1>>, X2>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_at_sf.cpp b/src/boost/libs/mp11/test/mp_at_sf.cpp
new file mode 100644
index 000000000..00463f9ff
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_at_sf.cpp
@@ -0,0 +1,39 @@
+
+// Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_valid;
+using boost::mp11::mp_at;
+using boost::mp11::mp_size_t;
+using boost::mp11::mp_list;
+
+int main()
+{
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, void, mp_size_t<0>>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, mp_list<>, mp_size_t<0>>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_at, mp_list<void>, mp_size_t<0>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, mp_list<void>, mp_size_t<1>>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_at, mp_list<void, void>, mp_size_t<0>>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_at, mp_list<void, void>, mp_size_t<1>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_at, mp_list<void, void>, mp_size_t<2>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_back.cpp b/src/boost/libs/mp11/test/mp_back.cpp
new file mode 100644
index 000000000..457364eee
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_back.cpp
@@ -0,0 +1,52 @@
+
+// Copyright 2015, 2019 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_back;
+
+    using L1 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L1>, void>));
+
+    using L2 = mp_list<float, void, int[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L2>, int[]>));
+
+    using L3 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L3>, int>));
+
+    using L4 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L4>, double>));
+
+    using L5 = std::add_const<void()>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L5>, void()>));
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    int const N = 137;
+
+    using L6 = mp_iota_c<N>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_back<L6>, mp_size_t<N-1>>));
+
+    using boost::mp11::mp_valid;
+
+    using L7 = mp_list<>;
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_back, L7>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_bind.cpp b/src/boost/libs/mp11/test/mp_bind.cpp
new file mode 100644
index 000000000..1174bf48c
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_bind.cpp
@@ -0,0 +1,106 @@
+
+// Copyright 2017 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/bind.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+struct X6 {};
+struct X7 {};
+struct X8 {};
+struct X9 {};
+
+template<class T> using add_pointer = T*;
+
+int main()
+{
+    using namespace boost::mp11;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_1::fn<X1>, X1>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_1::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X1>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_2::fn<X1, X2>, X2>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_2::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X2>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_3::fn<X1, X2, X3>, X3>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_3::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X3>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_4::fn<X1, X2, X3, X4>, X4>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_4::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X4>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_5::fn<X1, X2, X3, X4, X5>, X5>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_5::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X5>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_6::fn<X1, X2, X3, X4, X5, X6>, X6>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_6::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X6>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_7::fn<X1, X2, X3, X4, X5, X6, X7>, X7>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_7::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X7>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_8::fn<X1, X2, X3, X4, X5, X6, X7, X8>, X8>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_8::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X8>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<_9::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X9>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _1>::fn<X1>, X1*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _1>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X1*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _2>::fn<X1, X2>, X2*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _2>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X2*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _3>::fn<X1, X2, X3>, X3*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _3>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X3*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _4>::fn<X1, X2, X3, X4>, X4*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _4>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X4*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _5>::fn<X1, X2, X3, X4, X5>, X5*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _5>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X5*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _6>::fn<X1, X2, X3, X4, X5, X6>, X6*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _6>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X6*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _7>::fn<X1, X2, X3, X4, X5, X6, X7>, X7*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _7>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X7*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8>, X8*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X8*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind<add_pointer, _9>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X9*>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<
+        mp_bind<std::tuple,
+            mp_bind<add_pointer, _9>,
+            mp_bind<add_pointer, _8>,
+            mp_bind<add_pointer, _7>,
+            mp_bind<add_pointer, _6>,
+            mp_bind<add_pointer, _5>,
+            mp_bind<add_pointer, _4>,
+            mp_bind<add_pointer, _3>,
+            mp_bind<add_pointer, _2>,
+            mp_bind<add_pointer, _1>
+        >::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, std::tuple<X9*, X8*, X7*, X6*, X5*, X4*, X3*, X2*, X1*>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_bind_back.cpp b/src/boost/libs/mp11/test/mp_bind_back.cpp
new file mode 100644
index 000000000..f497a13be
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_bind_back.cpp
@@ -0,0 +1,63 @@
+
+// Copyright 2017 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class...> struct L {};
+template<class, class> struct P {};
+
+template<class T, class U> using is_base_of_t = typename std::is_base_of<T, U>::type;
+
+struct B1 {};
+struct B2 {};
+struct D: B1, B2 {};
+struct NB {};
+
+int main()
+{
+    using namespace boost::mp11;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back<L, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<int[1], int[2], int[3], char[1], char[2]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back_q<mp_quote<L>, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<int[1], int[2], int[3], char[1], char[2]>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back<P, char[1]>::fn<int[1]>, P<int[1], char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_back_q<mp_quote<P>, char[1]>::fn<int[1]>, P<int[1], char[1]>>));
+
+    //
+
+    using L1 = L<B1, B2, NB>;
+
+    {
+        using L2 = mp_transform<mp_bind_back<is_base_of_t, D>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_back<is_base_of_t, D>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform<mp_bind_back_q<mp_quote<is_base_of_t>, D>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_back_q<mp_quote<is_base_of_t>, D>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_bind_front.cpp b/src/boost/libs/mp11/test/mp_bind_front.cpp
new file mode 100644
index 000000000..bce077f1f
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_bind_front.cpp
@@ -0,0 +1,63 @@
+
+// Copyright 2017 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class...> struct L {};
+template<class, class> struct P {};
+
+template<class T, class U> using is_base_of_t = typename std::is_base_of<T, U>::type;
+
+struct B {};
+struct D1: B {};
+struct D2: B {};
+struct ND {};
+
+int main()
+{
+    using namespace boost::mp11;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front<L, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<char[1], char[2], int[1], int[2], int[3]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front_q<mp_quote<L>, char[1], char[2]>::fn<int[1], int[2], int[3]>, L<char[1], char[2], int[1], int[2], int[3]>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front<P, char[1]>::fn<int[1]>, P<char[1], int[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_front_q<mp_quote<P>, char[1]>::fn<int[1]>, P<char[1], int[1]>>));
+
+    //
+
+    using L1 = L<D1, D2, ND>;
+
+    {
+        using L2 = mp_transform<mp_bind_front<is_base_of_t, B>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_front<is_base_of_t, B>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform<mp_bind_front_q<mp_quote<is_base_of_t>, B>::fn, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    {
+        using L2 = mp_transform_q<mp_bind_front_q<mp_quote<is_base_of_t>, B>, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<L2, L<std::true_type, std::true_type, std::false_type>>));
+    }
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_bind_q.cpp b/src/boost/libs/mp11/test/mp_bind_q.cpp
new file mode 100644
index 000000000..0fa495cdf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_bind_q.cpp
@@ -0,0 +1,62 @@
+
+// Copyright 2017 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/bind.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+struct X6 {};
+struct X7 {};
+struct X8 {};
+struct X9 {};
+
+template<class T> using add_pointer = typename std::add_pointer<T>::type;
+
+int main()
+{
+    using namespace boost::mp11;
+
+    using Q_addp = mp_quote<add_pointer>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _1>::fn<X1>, X1*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _1>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X1*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _2>::fn<X1, X2>, X2*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _2>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X2*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _3>::fn<X1, X2, X3>, X3*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _3>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X3*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _4>::fn<X1, X2, X3, X4>, X4*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _4>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X4*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _5>::fn<X1, X2, X3, X4, X5>, X5*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _5>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X5*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _6>::fn<X1, X2, X3, X4, X5, X6>, X6*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _6>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X6*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _7>::fn<X1, X2, X3, X4, X5, X6, X7>, X7*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _7>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X7*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8>, X8*>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _8>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X8*>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_bind_q<Q_addp, _9>::fn<X1, X2, X3, X4, X5, X6, X7, X8, X9>, X9*>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_clear.cpp b/src/boost/libs/mp11/test/mp_clear.cpp
new file mode 100644
index 000000000..9684c7140
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_clear.cpp
@@ -0,0 +1,31 @@
+
+// Copyright 2015, 2017 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/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_clear;
+
+    using L1 = mp_list<int, void(), float[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_clear<L1>, mp_list<>>));
+
+    //
+
+    using L2 = std::tuple<int, char, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_clear<L2>, std::tuple<>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_compose.cpp b/src/boost/libs/mp11/test/mp_compose.cpp
new file mode 100644
index 000000000..46184a6ec
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_compose.cpp
@@ -0,0 +1,59 @@
+
+// Copyright 2017, 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T> struct F1 {};
+template<class T> struct F2 {};
+template<class T> struct F3 {};
+
+template<class T> using G1 = F1<T>;
+template<class T> using G2 = F2<T>;
+template<class T> using G3 = F3<T>;
+
+int main()
+{
+    using namespace boost::mp11;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<>::fn<void>, void>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<F1>::fn<void>, F1<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<G1>::fn<void>, F1<void>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<F1, F2>::fn<void>, F2<F1<void>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<G1, G2>::fn<void>, F2<F1<void>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<F1, F2, F3>::fn<void>, F3<F2<F1<void>>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose<G1, G2, G3>::fn<void>, F3<F2<F1<void>>>>));
+
+#endif
+
+    using QF1 = mp_quote<F1>;
+    using QF2 = mp_quote<F2>;
+    using QF3 = mp_quote<F3>;
+
+    using QG1 = mp_quote<G1>;
+    using QG2 = mp_quote<G2>;
+    using QG3 = mp_quote<G3>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<>::fn<void>, void>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QF1>::fn<void>, F1<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QG1>::fn<void>, F1<void>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QF1, QF2>::fn<void>, F2<F1<void>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QG1, QG2>::fn<void>, F2<F1<void>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QF1, QF2, QF3>::fn<void>, F3<F2<F1<void>>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_compose_q<QG1, QG2, QG3>::fn<void>, F3<F2<F1<void>>>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_cond.cpp b/src/boost/libs/mp11/test/mp_cond.cpp
new file mode 100644
index 000000000..08a625fa7
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_cond.cpp
@@ -0,0 +1,42 @@
+
+// Copyright 2017 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_cond;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_true, char[]>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_true, char[], void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_true, char[], void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_true, char[], void, void, void>, char[]>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_true, char[]>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_true, char[], void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_true, char[], void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_true, char[], void, void, void>, char[]>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_true, char[]>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_true, char[], void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_true, char[], void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_true, char[], void, void, void>, char[]>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_false, double, mp_true, char[]>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_false, double, mp_true, char[], void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_false, double, mp_true, char[], void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_cond<mp_false, int, mp_false, float, mp_false, double, mp_true, char[], void, void, void>, char[]>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_cond_sf.cpp b/src/boost/libs/mp11/test/mp_cond_sf.cpp
new file mode 100644
index 000000000..c1bb4de5d
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_cond_sf.cpp
@@ -0,0 +1,43 @@
+
+// Copyright 2017 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_cond;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_valid;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_true>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_cond, mp_true, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_cond, mp_true, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_cond, mp_false, void, mp_true, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void, mp_false>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void, mp_false, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_cond, mp_false, void, mp_false, void, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_cond, mp_false, void, mp_false, void, mp_true, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_contains.cpp b/src/boost/libs/mp11/test/mp_contains.cpp
new file mode 100644
index 000000000..04bfac64a
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_contains.cpp
@@ -0,0 +1,64 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_contains;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L1, void>, mp_false>));
+
+        using L2 = mp_list<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L2, void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L2, X1>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L2, X2>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L2, X3>, mp_true>));
+    }
+
+    {
+        using L3 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L3, void>, mp_false>));
+
+        using L4 = std::tuple<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L4, void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L4, X1>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L4, X2>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L4, X3>, mp_true>));
+    }
+
+    {
+        using L5 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L5, void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L5, X1>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_contains<L5, X2>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_copy_if.cpp b/src/boost/libs/mp11/test/mp_copy_if.cpp
new file mode 100644
index 000000000..0cf54d498
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_copy_if.cpp
@@ -0,0 +1,67 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+using boost::mp11::mp_bool;
+
+template<class N> using is_even = mp_bool<N::value % 2 == 0>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_copy_if;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L1, std::is_const>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_volatile>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_const>, mp_list<X1 const, X2 const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_pointer>, mp_list<X1*, X2*, X3*>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L1, std::is_const>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_volatile>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_const>, std::tuple<X1 const, X2 const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if<L2, std::is_pointer>, std::tuple<X1*, X2*, X3*>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 12;
+        using L1 = mp_iota_c<N>;
+
+        using R1 = mp_copy_if<L1, is_even>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<mp_size_t<0>, mp_size_t<2>, mp_size_t<4>, mp_size_t<6>, mp_size_t<8>, mp_size_t<10>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_copy_if_q.cpp b/src/boost/libs/mp11/test/mp_copy_if_q.cpp
new file mode 100644
index 000000000..ef75db222
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_copy_if_q.cpp
@@ -0,0 +1,72 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+using boost::mp11::mp_bool;
+
+struct Q_is_even
+{
+    template<class N> using fn = mp_bool<N::value % 2 == 0>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_copy_if_q;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L1, mp_quote<std::is_const>>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_volatile>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_const>>, mp_list<X1 const, X2 const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_pointer>>, mp_list<X1*, X2*, X3*>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L1, mp_quote<std::is_const>>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_volatile>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_const>>, std::tuple<X1 const, X2 const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_copy_if_q<L2, mp_quote<std::is_pointer>>, std::tuple<X1*, X2*, X3*>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 12;
+        using L1 = mp_iota_c<N>;
+
+        using R1 = mp_copy_if_q<L1, Q_is_even>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<mp_size_t<0>, mp_size_t<2>, mp_size_t<4>, mp_size_t<6>, mp_size_t<8>, mp_size_t<10>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_count.cpp b/src/boost/libs/mp11/test/mp_count.cpp
new file mode 100644
index 000000000..41df7ddb5
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_count.cpp
@@ -0,0 +1,63 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_count;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L1, void>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L2, void>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L2, X1>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L2, X2>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L2, X3>, mp_size_t<3>>));
+    }
+
+    {
+        using L3 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L3, void>, mp_size_t<0>>));
+
+        using L4 = std::tuple<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L4, void>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L4, X1>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L4, X2>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L4, X3>, mp_size_t<3>>));
+    }
+
+    {
+        using L5 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L5, void>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L5, X1>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count<L5, X2>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_count_if.cpp b/src/boost/libs/mp11/test/mp_count_if.cpp
new file mode 100644
index 000000000..ad728a9b1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_count_if.cpp
@@ -0,0 +1,59 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_count_if;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L1, std::is_const>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_volatile>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_const>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_pointer>, mp_size_t<3>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L1, std::is_const>, mp_size_t<0>>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_volatile>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_const>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_pointer>, mp_size_t<3>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_volatile>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_const>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if<L2, std::is_pointer>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_count_if_q.cpp b/src/boost/libs/mp11/test/mp_count_if_q.cpp
new file mode 100644
index 000000000..d76ab4d2b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_count_if_q.cpp
@@ -0,0 +1,61 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_count_if_q;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L1, mp_quote<std::is_const>>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_const>>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<3>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L1, mp_quote<std::is_const>>, mp_size_t<0>>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_const>>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<3>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_const>>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_count_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_defer.cpp b/src/boost/libs/mp11/test/mp_defer.cpp
new file mode 100644
index 000000000..e09973eed
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_defer.cpp
@@ -0,0 +1,65 @@
+
+// Copyright 2015-2017 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_identity;
+using boost::mp11::mp_true;
+using boost::mp11::mp_false;
+
+template<class T> struct has_type
+{
+    template<class U> static mp_true f( mp_identity<typename U::type>* );
+    template<class U> static mp_false f( ... );
+
+    using type = decltype( f<T>(0) );
+
+    static const bool value = type::value;
+};
+
+using boost::mp11::mp_defer;
+
+template<class T> using add_pointer = T*;
+template<class... T> using add_pointer_impl = mp_defer<add_pointer, T...>;
+
+using boost::mp11::mp_quote;
+
+using Q_add_pointer = mp_quote<add_pointer>;
+template<class... T> using Q_add_pointer_impl = mp_defer<Q_add_pointer::fn, T...>;
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((has_type<add_pointer_impl<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<add_pointer_impl<void>::type, void*>));
+
+    BOOST_TEST_TRAIT_TRUE((has_type<add_pointer_impl<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<add_pointer_impl<int>::type, int*>));
+
+    BOOST_TEST_TRAIT_FALSE((has_type<add_pointer_impl<>>));
+    BOOST_TEST_TRAIT_FALSE((has_type<add_pointer_impl<void, void>>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    BOOST_TEST_TRAIT_TRUE((has_type<Q_add_pointer_impl<void>>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((std::is_same<Q_add_pointer_impl<void>::type, void*>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    BOOST_TEST_TRAIT_TRUE((has_type<Q_add_pointer_impl<int>>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((std::is_same<Q_add_pointer_impl<int>::type, int*>));
+
+    BOOST_TEST_TRAIT_FALSE((has_type<Q_add_pointer_impl<>>));
+    BOOST_TEST_TRAIT_FALSE((has_type<Q_add_pointer_impl<void, void>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_drop.cpp b/src/boost/libs/mp11/test/mp_drop.cpp
new file mode 100644
index 000000000..186aa948e
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_drop.cpp
@@ -0,0 +1,85 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_drop;
+    using boost::mp11::mp_drop_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L1, mp_size_t<0>>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 0>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 1>, mp_list<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 2>, mp_list<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 3>, mp_list<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 4>, mp_list<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 5>, mp_list<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<0>>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<1>>, mp_list<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<2>>, mp_list<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<3>>, mp_list<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<4>>, mp_list<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<5>>, mp_list<>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L1, mp_size_t<0>>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 0>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 1>, std::tuple<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 2>, std::tuple<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 3>, std::tuple<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 4>, std::tuple<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L2, 5>, std::tuple<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<0>>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<1>>, std::tuple<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<2>>, std::tuple<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<3>>, std::tuple<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<4>>, std::tuple<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L2, mp_size_t<5>>, std::tuple<>>));
+    }
+
+    {
+        using L1 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_drop<L1, mp_size_t<0>>, L1>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_empty.cpp b/src/boost/libs/mp11/test/mp_empty.cpp
new file mode 100644
index 000000000..87e0fb7cf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_empty.cpp
@@ -0,0 +1,49 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_empty;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    using L1 = mp_list<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L1>, mp_true>));
+
+    using L2 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L2>, mp_false>));
+
+    using L3 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L3>, mp_false>));
+
+    using L4 = std::tuple<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L4>, mp_true>));
+
+    using L5 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L5>, mp_false>));
+
+    using L6 = std::tuple<int, int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L6>, mp_false>));
+
+    using L7 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L7>, mp_false>));
+
+    using L8 = std::add_const<void()>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_empty<L8>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_erase.cpp b/src/boost/libs/mp11/test/mp_erase.cpp
new file mode 100644
index 000000000..10e9638cf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_erase.cpp
@@ -0,0 +1,171 @@
+
+//  Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_erase;
+    using boost::mp11::mp_erase_c;
+    using boost::mp11::mp_size_t;
+
+    using _0 = mp_size_t<0>;
+    using _1 = mp_size_t<1>;
+    using _2 = mp_size_t<2>;
+    using _3 = mp_size_t<3>;
+    using _4 = mp_size_t<4>;
+    using _5 = mp_size_t<5>;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L1, 0, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L1, _0, _0>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 4, 4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 5, 5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _4, _4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _5, _5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 1>, mp_list<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 2>, mp_list<X1, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 3>, mp_list<X1, X2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 4>, mp_list<X1, X2, X3, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 4, 5>, mp_list<X1, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _1>, mp_list<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _2>, mp_list<X1, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _3>, mp_list<X1, X2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _4>, mp_list<X1, X2, X3, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _4, _5>, mp_list<X1, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 2>, mp_list<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 3>, mp_list<X1, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 4>, mp_list<X1, X2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 5>, mp_list<X1, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _2>, mp_list<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _3>, mp_list<X1, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _4>, mp_list<X1, X2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _5>, mp_list<X1, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 3>, mp_list<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 4>, mp_list<X1, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 5>, mp_list<X1, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _3>, mp_list<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _4>, mp_list<X1, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _5>, mp_list<X1, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 4>, mp_list<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 5>, mp_list<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 5>, mp_list<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _4>, mp_list<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _5>, mp_list<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _5>, mp_list<>>));
+
+        using L3 = mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L3, 8, 18>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L3, mp_size_t<8>, mp_size_t<18>>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L1, 0, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L1, _0, _0>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 4, 4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 5, 5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _4, _4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _5, _5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 1>, std::tuple<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 2>, std::tuple<X1, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 3>, std::tuple<X1, X2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 4>, std::tuple<X1, X2, X3, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 4, 5>, std::tuple<X1, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _1>, std::tuple<X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _2>, std::tuple<X1, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _3>, std::tuple<X1, X2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _4>, std::tuple<X1, X2, X3, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _4, _5>, std::tuple<X1, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 2>, std::tuple<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 3>, std::tuple<X1, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 4>, std::tuple<X1, X2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 3, 5>, std::tuple<X1, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _2>, std::tuple<X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _3>, std::tuple<X1, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _4>, std::tuple<X1, X2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _3, _5>, std::tuple<X1, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 3>, std::tuple<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 4>, std::tuple<X1, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 2, 5>, std::tuple<X1, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _3>, std::tuple<X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _4>, std::tuple<X1, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _2, _5>, std::tuple<X1, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 4>, std::tuple<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 1, 5>, std::tuple<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L2, 0, 5>, std::tuple<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _4>, std::tuple<X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _1, _5>, std::tuple<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L2, _0, _5>, std::tuple<>>));
+
+        using L3 = std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase_c<L3, 8, 18>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_erase<L3, mp_size_t<8>, mp_size_t<18>>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_eval_if.cpp b/src/boost/libs/mp11/test/mp_eval_if.cpp
new file mode 100644
index 000000000..7e44c6750
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_eval_if.cpp
@@ -0,0 +1,52 @@
+
+// Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_eval_if_c;
+    using boost::mp11::mp_identity;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_c<true, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_c<false, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    using boost::mp11::mp_eval_if;
+    using boost::mp11::mp_eval_if_q;
+    using boost::mp11::mp_quote;
+
+    using qt_identity = mp_quote<mp_identity>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<std::true_type, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<std::false_type, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<std::true_type, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<std::false_type, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    using boost::mp11::mp_int;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<mp_int<-7>, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<mp_int<0>, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<mp_int<-7>, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<mp_int<0>, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<mp_size_t<14>, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if<mp_size_t<0>, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<mp_size_t<14>, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_q<mp_size_t<0>, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_eval_if_not.cpp b/src/boost/libs/mp11/test/mp_eval_if_not.cpp
new file mode 100644
index 000000000..987e03739
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_eval_if_not.cpp
@@ -0,0 +1,47 @@
+
+// Copyright 2015, 2017, 2019 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_identity;
+    using boost::mp11::mp_eval_if_not;
+    using boost::mp11::mp_eval_if_not_q;
+    using boost::mp11::mp_quote;
+
+    using qt_identity = mp_quote<mp_identity>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<std::false_type, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<std::true_type, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<std::false_type, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<std::true_type, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    using boost::mp11::mp_int;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<mp_int<0>, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<mp_int<-7>, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<mp_int<0>, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<mp_int<-7>, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<mp_size_t<0>, char[], mp_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not<mp_size_t<14>, char[], mp_identity, void()>, mp_identity<void()>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<mp_size_t<0>, char[], qt_identity, void, void, void>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_eval_if_not_q<mp_size_t<14>, char[], qt_identity, void()>, mp_identity<void()>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_eval_if_sf.cpp b/src/boost/libs/mp11/test/mp_eval_if_sf.cpp
new file mode 100644
index 000000000..aed1191d8
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_eval_if_sf.cpp
@@ -0,0 +1,47 @@
+
+// Copyright 2017 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/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_eval_if;
+using boost::mp11::mp_eval_if_q;
+using boost::mp11::mp_identity_t;
+using boost::mp11::mp_valid;
+using boost::mp11::mp_quote;
+
+template<class C, class... A> using eval_if = mp_eval_if<C, void, mp_identity_t, A...>;
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((mp_valid<eval_if, std::true_type>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<eval_if, std::true_type, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<eval_if, std::true_type, void, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<eval_if, std::true_type, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<eval_if, std::false_type>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<eval_if, std::false_type, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<eval_if, std::false_type, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<eval_if, std::false_type, void, void, void>));
+
+    using Qi = mp_quote<mp_identity_t>;
+
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_eval_if_q, std::true_type, void, Qi>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_eval_if_q, std::true_type, void, Qi, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_eval_if_q, std::true_type, void, Qi, void, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_eval_if_q, std::true_type, void, Qi, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_eval_if_q, std::false_type, void, Qi>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_eval_if_q, std::false_type, void, Qi, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_eval_if_q, std::false_type, void, Qi, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_eval_if_q, std::false_type, void, Qi, void, void, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_eval_or.cpp b/src/boost/libs/mp11/test/mp_eval_or.cpp
new file mode 100644
index 000000000..c56a91b46
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_eval_or.cpp
@@ -0,0 +1,51 @@
+
+// Copyright 2019 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/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <cstddef>
+
+template<class T> using difference_type = typename T::difference_type;
+
+struct X
+{
+};
+
+struct Y
+{
+    using difference_type = int;
+};
+
+int main()
+{
+    using boost::mp11::mp_eval_or;
+    using boost::mp11::mp_eval_or_q;
+    using boost::mp11::mp_identity;
+    using boost::mp11::mp_quote;
+
+    BOOST_TEST_TRAIT_SAME(mp_eval_or<void, mp_identity>, void);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or<void, mp_identity, int>, mp_identity<int>);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or<void, mp_identity, int, int>, void);
+
+    using Q_identity = mp_quote<mp_identity>;
+
+    BOOST_TEST_TRAIT_SAME(mp_eval_or_q<void, Q_identity>, void);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or_q<void, Q_identity, int>, mp_identity<int>);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or_q<void, Q_identity, int, int>, void);
+
+    BOOST_TEST_TRAIT_SAME(mp_eval_or<std::ptrdiff_t, difference_type, X>, std::ptrdiff_t);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or<std::ptrdiff_t, difference_type, Y>, int);
+
+    using Q_diff_type = mp_quote<difference_type>;
+
+    BOOST_TEST_TRAIT_SAME(mp_eval_or_q<std::ptrdiff_t, Q_diff_type, X>, std::ptrdiff_t);
+    BOOST_TEST_TRAIT_SAME(mp_eval_or_q<std::ptrdiff_t, Q_diff_type, Y>, int);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_fill.cpp b/src/boost/libs/mp11/test/mp_fill.cpp
new file mode 100644
index 000000000..1b5fc2ef5
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_fill.cpp
@@ -0,0 +1,40 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_fill;
+
+    using L1 = mp_list<int, void(), float[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fill<L1, X1>, mp_list<X1, X1, X1>>));
+
+    //
+
+    using L2 = std::tuple<int, char, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fill<L2, X1>, std::tuple<X1, X1, X1>>));
+
+    //
+
+    using L3 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fill<L3, X1>, std::pair<X1, X1>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_filter.cpp b/src/boost/libs/mp11/test/mp_filter.cpp
new file mode 100644
index 000000000..6a2ea13f0
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_filter.cpp
@@ -0,0 +1,78 @@
+
+// Copyright 2019 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using boost::mp11::mp_int;
+
+template<class N> using mod_2 = mp_int<N::value % 2>;
+template<class N> using mod_3 = mp_int<N::value % 3>;
+template<class N> using mod_6 = mp_int<N::value % 6>;
+
+using boost::mp11::mp_not;
+using boost::mp11::mp_plus;
+
+template<class T> using P1 = mp_not<mod_6<T>>;
+template<class T1, class... T> using P2 = mp_not<mp_plus<T...>>;
+
+using boost::mp11::mp_bool;
+
+template<std::size_t N> struct second_is
+{
+    template<class T1, class T2> using fn = mp_bool< T2::value == N >;
+};
+
+using boost::mp11::mp_first;
+using boost::mp11::mp_filter_q;
+using boost::mp11::mp_iota;
+using boost::mp11::mp_size;
+
+template<class L, std::size_t N> using at_c = mp_first< mp_filter_q< second_is<N>, L, mp_iota<mp_size<L>> > >;
+
+int main()
+{
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_filter;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_transform;
+
+    {
+        int const N = 12;
+        using L1 = mp_iota_c<N>;
+
+        using R1 = mp_filter<P1, L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<mp_size_t<0>, mp_size_t<6>>>));
+
+        using L2 = mp_transform<mod_2, L1>;
+        using L3 = mp_transform<mod_3, L1>;
+        using L6 = mp_transform<mod_6, L1>;
+
+        using R2 = mp_filter<P2, L1, L6>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, mp_list<mp_size_t<0>, mp_size_t<6>>>));
+
+        using R3 = mp_filter<P2, L1, L2, L3>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_list<mp_size_t<0>, mp_size_t<6>>>));
+    }
+
+    {
+        int const N = 64;
+        int const M = 17;
+
+        using L1 = mp_iota_c<N>;
+        using R1 = at_c<L1, M>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_size_t<M>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_find.cpp b/src/boost/libs/mp11/test/mp_find.cpp
new file mode 100644
index 000000000..21aeb26b6
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_find.cpp
@@ -0,0 +1,63 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_find;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L1, void>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X2, X2, X3, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L2, void>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L2, X1>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L2, X2>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L2, X3>, mp_size_t<3>>));
+    }
+
+    {
+        using L3 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L3, void>, mp_size_t<0>>));
+
+        using L4 = std::tuple<X1, X2, X2, X3, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L4, void>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L4, X1>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L4, X2>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L4, X3>, mp_size_t<3>>));
+    }
+
+    {
+        using L5 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L5, void>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L5, X1>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find<L5, X2>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_find_if.cpp b/src/boost/libs/mp11/test/mp_find_if.cpp
new file mode 100644
index 000000000..6310390eb
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_find_if.cpp
@@ -0,0 +1,59 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_find_if;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L1, std::is_const>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X1 const, X1 const, X1*, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_volatile>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_const>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_pointer>, mp_size_t<3>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L1, std::is_const>, mp_size_t<0>>));
+
+        using L2 = std::tuple<X1, X1 const, X1 const, X1*, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_volatile>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_const>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_pointer>, mp_size_t<3>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_volatile>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_const>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if<L2, std::is_pointer>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_find_if_q.cpp b/src/boost/libs/mp11/test/mp_find_if_q.cpp
new file mode 100644
index 000000000..73aaf4ae3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_find_if_q.cpp
@@ -0,0 +1,61 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_find_if_q;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L1, mp_quote<std::is_const>>, mp_size_t<0>>));
+
+        using L2 = mp_list<X1, X1 const, X1 const, X1*, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_const>>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<3>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L1, mp_quote<std::is_const>>, mp_size_t<0>>));
+
+        using L2 = std::tuple<X1, X1 const, X1 const, X1*, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<6>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_const>>, mp_size_t<1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<3>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_volatile>>, mp_size_t<2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_const>>, mp_size_t<0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_find_if_q<L2, mp_quote<std::is_pointer>>, mp_size_t<1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_flatten.cpp b/src/boost/libs/mp11/test/mp_flatten.cpp
new file mode 100644
index 000000000..403b870a1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_flatten.cpp
@@ -0,0 +1,101 @@
+
+// Copyright 2019 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_flatten;
+    using boost::mp11::mp_transform;
+
+    {
+        using L1 = mp_list<>;
+        using L2 = mp_list<void>;
+        using L3 = mp_list<void, void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L3>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L1, L1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L2, L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L3, L3>, L3>));
+
+        using L4 = mp_transform<mp_list, L3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4, mp_list<>>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4, std::tuple<>>, L4>));
+
+        using L5 = mp_transform<std::tuple, L3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5>, L5>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5, mp_list<>>, L5>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5, std::tuple<>>, L3>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+        using L2 = std::tuple<void>;
+        using L3 = std::tuple<void, void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L3>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L1, L1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L2, L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L3, L3>, L3>));
+
+        using L4 = mp_transform<mp_list, L3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4, mp_list<>>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L4, std::tuple<>>, L4>));
+
+        using L5 = mp_transform<std::tuple, L3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5, mp_list<>>, L5>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_flatten<L5, std::tuple<>>, L3>));
+    }
+
+    {
+        using L1 = mp_list<std::tuple<>, int, mp_list<>, void, mp_list<char, double>, std::pair<int, void>>;
+
+        using R1 = mp_flatten<L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<std::tuple<>, int, void, char, double, std::pair<int, void>>>));
+
+        using R2 = mp_flatten<L1, std::pair<void, void>>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, mp_list<std::tuple<>, int, mp_list<>, void, mp_list<char, double>, int, void>>));
+
+        using R3 = mp_flatten<L1, std::tuple<>>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_list<int, mp_list<>, void, mp_list<char, double>, std::pair<int, void>>>));
+    }
+
+    {
+        using L1 = std::tuple<std::tuple<>, int, mp_list<>, void, mp_list<char, double>, std::pair<int, void>>;
+
+        using R1 = mp_flatten<L1, mp_list<void, void, void, void>>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, std::tuple<std::tuple<>, int, void, char, double, std::pair<int, void>>>));
+
+        using R2 = mp_flatten<L1, std::pair<void, void>>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, std::tuple<std::tuple<>, int, mp_list<>, void, mp_list<char, double>, int, void>>));
+
+        using R3 = mp_flatten<L1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, std::tuple<int, mp_list<>, void, mp_list<char, double>, std::pair<int, void>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_fold.cpp b/src/boost/libs/mp11/test/mp_fold.cpp
new file mode 100644
index 000000000..8db9cc9e7
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_fold.cpp
@@ -0,0 +1,79 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T1, class T2> struct F {};
+
+using boost::mp11::mp_plus;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_fold;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<mp_list<>, void, F>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<mp_list<X1>, void, F>, F<void, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<mp_list<X1, X2>, void, F>, F<F<void, X1>, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<mp_list<X1, X2, X3>, void, F>, F<F<F<void, X1>, X2>, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<mp_list<X1, X2, X3, X4>, void, F>, F<F<F<F<void, X1>, X2>, X3>, X4>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<>, void, F>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1>, void, F>, F<void, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1, X2>, void, F>, F<F<void, X1>, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1, X2, X3>, void, F>, F<F<F<void, X1>, X2>, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1, X2, X3, X4>, void, F>, F<F<F<F<void, X1>, X2>, X3>, X4>>));
+    }
+
+    using boost::mp11::mp_push_back;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_push_back>, mp_list<X1, X2, X3, X4>>));
+    }
+
+    using boost::mp11::mp_push_front;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_push_front>, mp_list<X4, X3, X2, X1>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_reverse;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 37;
+
+        using L = mp_iota_c<N>;
+
+        using R1 = mp_fold<L, mp_list<>, mp_push_back>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, L>));
+
+        using R2 = mp_fold<L, mp_list<>, mp_push_front>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, mp_reverse<L>>));
+
+        using R3 = mp_fold<L, mp_size_t<0>, mp_plus>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_size_t<N*(N-1)/2>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_fold_q.cpp b/src/boost/libs/mp11/test/mp_fold_q.cpp
new file mode 100644
index 000000000..475cf0828
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_fold_q.cpp
@@ -0,0 +1,62 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T1, class T2> struct F {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_fold_q;
+    using boost::mp11::mp_quote;
+
+    using Q = mp_quote<F>;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<mp_list<>, void, Q>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<mp_list<X1>, void, Q>, F<void, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<mp_list<X1, X2>, void, Q>, F<F<void, X1>, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<mp_list<X1, X2, X3>, void, Q>, F<F<F<void, X1>, X2>, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<mp_list<X1, X2, X3, X4>, void, Q>, F<F<F<F<void, X1>, X2>, X3>, X4>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<>, void, Q>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1>, void, Q>, F<void, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1, X2>, void, Q>, F<F<void, X1>, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1, X2, X3>, void, Q>, F<F<F<void, X1>, X2>, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1, X2, X3, X4>, void, Q>, F<F<F<F<void, X1>, X2>, X3>, X4>>));
+    }
+
+    using boost::mp11::mp_push_back;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_quote<mp_push_back>>, mp_list<X1, X2, X3, X4>>));
+    }
+
+    using boost::mp11::mp_push_front;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_fold_q<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_quote<mp_push_front>>, mp_list<X4, X3, X2, X1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_for_each.cpp b/src/boost/libs/mp11/test/mp_for_each.cpp
new file mode 100644
index 000000000..d727e027a
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_for_each.cpp
@@ -0,0 +1,104 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_MSVC
+# pragma warning( disable: 4503 ) // decorated name length exceeded
+# pragma warning( disable: 4307 ) // '*': integral constant overflow
+# pragma warning( disable: 4244 ) // conversion from size_t to uint32_t
+# pragma warning( disable: 4267 ) // conversion from size_t to uint32_t
+#endif
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <tuple>
+#include <cstdint>
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+# define CONSTEXPR14 constexpr
+#else
+# define CONSTEXPR14
+#endif
+
+struct F
+{
+    int s;
+
+    CONSTEXPR14 void operator()( int ) { s = s * 10 + 1; }
+    CONSTEXPR14 void operator()( short ) { s = s * 10 + 2; }
+    CONSTEXPR14 void operator()( char ) { s = s * 10 + 3; }
+};
+
+struct G
+{
+    std::uint32_t s;
+    CONSTEXPR14 void operator()( std::uint32_t i ) { s = s * 3 + i; }
+};
+
+using boost::mp11::mp_list;
+using boost::mp11::mp_for_each;
+using boost::mp11::mp_iota_c;
+
+int main()
+{
+    BOOST_TEST_EQ( (mp_for_each<mp_list<>>( 11 )), 11 );
+    BOOST_TEST_EQ( (mp_for_each<mp_list<int>>( F{0} ).s), 1 );
+    BOOST_TEST_EQ( (mp_for_each<mp_list<int, short>>( F{0} ).s), 12 );
+    BOOST_TEST_EQ( (mp_for_each<mp_list<int, short, char>>( F{0} ).s), 123 );
+
+    BOOST_TEST_EQ( (mp_for_each<std::tuple<>>( 11 )), 11 );
+    BOOST_TEST_EQ( (mp_for_each<std::tuple<int>>( F{0} ).s), 1 );
+    BOOST_TEST_EQ( (mp_for_each<std::tuple<int, short>>( F{0} ).s), 12 );
+    BOOST_TEST_EQ( (mp_for_each<std::tuple<int, short, char>>( F{0} ).s), 123 );
+
+    BOOST_TEST_EQ( (mp_for_each<std::pair<int, short>>( F{0} ).s), 12 );
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+#else
+
+    using L = mp_iota_c<1089>;
+    std::uint32_t const R = 598075296;
+
+    BOOST_TEST_EQ( (mp_for_each<L>( G{0} ).s), R );
+
+    {
+        G g{0};
+        mp_for_each<L>( g );
+        BOOST_TEST_EQ( g.s, R );
+    }
+
+#endif
+
+#if defined( BOOST_MP11_NO_CONSTEXPR ) || ( !defined( __GLIBCXX__ ) && __cplusplus < 201400L )
+#else
+
+    static_assert( mp_for_each<mp_list<>>( 11 ) == 11, "mp_for_each<mp_list<>>( 11 ) == 11" );
+    static_assert( mp_for_each<std::tuple<>>( 12 ) == 12, "mp_for_each<std::tuple<>>( 12 ) == 12" );
+
+#endif
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+    constexpr auto r1 = mp_for_each<mp_list<int, short, char>>( F{0} );
+    static_assert( r1.s == 123, "r1.s == 123" );
+
+    constexpr auto r2 = mp_for_each<std::tuple<int, short, char>>( F{0} );
+    static_assert( r2.s == 123, "r2.s == 123" );
+
+    constexpr auto r3 = mp_for_each<std::pair<int, short>>( F{0} );
+    static_assert( r3.s == 12, "r3.s == 12" );
+
+    constexpr auto r4 = mp_for_each<L>( G{0} );
+    static_assert( r4.s == R, "r4.s == R" );
+
+#endif
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_from_sequence.cpp b/src/boost/libs/mp11/test/mp_from_sequence.cpp
new file mode 100644
index 000000000..a06d92827
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_from_sequence.cpp
@@ -0,0 +1,43 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/integer_sequence.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class T, T... I> struct S;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_from_sequence;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::make_integer_sequence;
+    using boost::mp11::make_index_sequence;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<S<int>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<S<int, 1>>, mp_list<mp_int<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<S<int, 1, 3>>, mp_list<mp_int<1>, mp_int<3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<S<int, 1, 3, 5>>, mp_list<mp_int<1>, mp_int<3>, mp_int<5>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_integer_sequence<int, 0>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_integer_sequence<int, 1>>, mp_list<mp_int<0>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_integer_sequence<int, 2>>, mp_list<mp_int<0>, mp_int<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_integer_sequence<int, 3>>, mp_list<mp_int<0>, mp_int<1>, mp_int<2>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_index_sequence<0>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_index_sequence<1>>, mp_list<mp_size_t<0>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_index_sequence<2>>, mp_list<mp_size_t<0>, mp_size_t<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_from_sequence<make_index_sequence<3>>, mp_list<mp_size_t<0>, mp_size_t<1>, mp_size_t<2>>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_front.cpp b/src/boost/libs/mp11/test/mp_front.cpp
new file mode 100644
index 000000000..3edb856c3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_front.cpp
@@ -0,0 +1,43 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_front;
+    using boost::mp11::mp_first;
+
+    using L1 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_front<L1>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_first<L1>, void>));
+
+    using L2 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_front<L2>, int[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_first<L2>, int[]>));
+
+    using L3 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_front<L3>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_first<L3>, int>));
+
+    using L4 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_front<L4>, char>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_first<L4>, char>));
+
+    using L5 = std::add_const<void()>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_front<L5>, void()>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_first<L5>, void()>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_identity.cpp b/src/boost/libs/mp11/test/mp_identity.cpp
new file mode 100644
index 000000000..3198718b0
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_identity.cpp
@@ -0,0 +1,33 @@
+
+//  Copyright 2015 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/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+struct X {};
+
+int main()
+{
+    using boost::mp11::mp_identity;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity<void const volatile>::type, void const volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity<void()>::type, void()>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity<int const[]>::type, int const[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity<X>::type, X>));
+
+    using boost::mp11::mp_identity_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity_t<void const volatile>, void const volatile>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity_t<void()>, void()>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity_t<int const[]>, int const[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_identity_t<X>, X>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_if.cpp b/src/boost/libs/mp11/test/mp_if.cpp
new file mode 100644
index 000000000..1a5bca9bb
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_if.cpp
@@ -0,0 +1,38 @@
+
+//  Copyright 2015 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_if_c;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if_c<true, char[], void()>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if_c<false, char[], void()>, void()>));
+
+    using boost::mp11::mp_if;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<std::true_type, char[], void()>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<std::false_type, char[], void()>, void()>));
+
+    using boost::mp11::mp_int;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<mp_int<-7>, char[], void()>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<mp_int<0>, char[], void()>, void()>));
+
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<mp_size_t<14>, char[], void()>, char[]>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_if<mp_size_t<0>, char[], void()>, void()>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_if_sf.cpp b/src/boost/libs/mp11/test/mp_if_sf.cpp
new file mode 100644
index 000000000..15ef3091e
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_if_sf.cpp
@@ -0,0 +1,24 @@
+
+//  Copyright 2017 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/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_if;
+    using boost::mp11::mp_valid;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_if, std::false_type, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_if, std::false_type, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_if, std::false_type, void, void, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_inherit.cpp b/src/boost/libs/mp11/test/mp_inherit.cpp
new file mode 100644
index 000000000..dfd5fc462
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_inherit.cpp
@@ -0,0 +1,27 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_inherit;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_base_of<X1, mp_inherit<X1, X2, X3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_base_of<X2, mp_inherit<X1, X2, X3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_base_of<X3, mp_inherit<X1, X2, X3>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_insert.cpp b/src/boost/libs/mp11/test/mp_insert.cpp
new file mode 100644
index 000000000..da5bc69b3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_insert.cpp
@@ -0,0 +1,137 @@
+
+//  Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+struct Y1 {};
+struct Y2 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_insert;
+    using boost::mp11::mp_insert_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0, Y1>, mp_list<Y1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>, Y1>, mp_list<Y1>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0, Y1, Y2>, mp_list<Y1, Y2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>, Y1, Y2>, mp_list<Y1, Y2>>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 0, Y1, Y2>, mp_list<Y1, Y2, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 1, Y1, Y2>, mp_list<X1, Y1, Y2, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 2, Y1, Y2>, mp_list<X1, X2, Y1, Y2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 3, Y1, Y2>, mp_list<X1, X2, X3, Y1, Y2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 4, Y1, Y2>, mp_list<X1, X2, X3, X4, Y1, Y2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 5, Y1, Y2>, mp_list<X1, X2, X3, X4, X5, Y1, Y2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<0>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<1>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<2>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<3>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<4>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<5>>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<0>, Y1, Y2>, mp_list<Y1, Y2, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<1>, Y1, Y2>, mp_list<X1, Y1, Y2, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<2>, Y1, Y2>, mp_list<X1, X2, Y1, Y2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<3>, Y1, Y2>, mp_list<X1, X2, X3, Y1, Y2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<4>, Y1, Y2>, mp_list<X1, X2, X3, X4, Y1, Y2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<5>, Y1, Y2>, mp_list<X1, X2, X3, X4, X5, Y1, Y2>>));
+
+        using L3 = mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L3, 8>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L3, mp_size_t<9>>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L3, 8, Y1, Y2>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, Y1, Y2, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L3, mp_size_t<9>, Y1, Y2>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, Y1, Y2, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0, Y1>, std::tuple<Y1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>, Y1>, std::tuple<Y1>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L1, 0, Y1, Y2>, std::tuple<Y1, Y2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L1, mp_size_t<0>, Y1, Y2>, std::tuple<Y1, Y2>>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 0>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 1>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 3>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 4>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 5>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 0, Y1, Y2>, std::tuple<Y1, Y2, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 1, Y1, Y2>, std::tuple<X1, Y1, Y2, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 2, Y1, Y2>, std::tuple<X1, X2, Y1, Y2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 3, Y1, Y2>, std::tuple<X1, X2, X3, Y1, Y2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 4, Y1, Y2>, std::tuple<X1, X2, X3, X4, Y1, Y2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L2, 5, Y1, Y2>, std::tuple<X1, X2, X3, X4, X5, Y1, Y2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<0>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<1>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<2>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<3>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<4>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<5>>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<0>, Y1, Y2>, std::tuple<Y1, Y2, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<1>, Y1, Y2>, std::tuple<X1, Y1, Y2, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<2>, Y1, Y2>, std::tuple<X1, X2, Y1, Y2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<3>, Y1, Y2>, std::tuple<X1, X2, X3, Y1, Y2, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<4>, Y1, Y2>, std::tuple<X1, X2, X3, X4, Y1, Y2, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L2, mp_size_t<5>, Y1, Y2>, std::tuple<X1, X2, X3, X4, X5, Y1, Y2>>));
+
+        using L3 = std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L3, 8>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L3, mp_size_t<9>>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert_c<L3, 8, Y1, Y2>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, Y1, Y2, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_insert<L3, mp_size_t<9>, Y1, Y2>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, Y1, Y2, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_invoke_q.cpp b/src/boost/libs/mp11/test/mp_invoke_q.cpp
new file mode 100644
index 000000000..777f44bbf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_invoke_q.cpp
@@ -0,0 +1,63 @@
+
+//  Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_invoke_q;
+using boost::mp11::mp_size_t;
+
+struct Q1
+{
+    template<class...> using fn = void;
+};
+
+struct Q2
+{
+    template<class...> class fn;
+};
+
+struct Q3
+{
+    template<class... T> using fn = mp_size_t<sizeof...(T)>;
+};
+
+struct Q4
+{
+    template<class T1, class... T> using fn = T1;
+};
+
+struct Q5
+{
+    template<class T1, class T2> using fn = T2;
+};
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q1>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q1, int>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q1, int[], char[]>, void>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q2>, Q2::fn<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q2, int>, Q2::fn<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q2, int[], char[]>, Q2::fn<int[], char[]>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q3>, mp_size_t<0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q3, int>, mp_size_t<1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q3, int[], char[]>, mp_size_t<2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q4, int>, int>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q4, int[], char[]>, int[]>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q5, int, float>, float>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_invoke_q_sf.cpp b/src/boost/libs/mp11/test/mp_invoke_q_sf.cpp
new file mode 100644
index 000000000..26e2912b3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_invoke_q_sf.cpp
@@ -0,0 +1,44 @@
+
+// Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_invoke_q;
+using boost::mp11::mp_quote;
+using boost::mp11::mp_quote_trait;
+using boost::mp11::mp_valid;
+using boost::mp11::mp_identity;
+using boost::mp11::mp_identity_t;
+
+int main()
+{
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, void, void, void>));
+
+    using Qi = mp_quote<mp_identity_t>;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, Qi>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_invoke_q, Qi, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, Qi, void, void>));
+
+    using Qt = mp_quote_trait<mp_identity>;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, Qt>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_invoke_q, Qt, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_invoke_q, Qt, void, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_iota.cpp b/src/boost/libs/mp11/test/mp_iota.cpp
new file mode 100644
index 000000000..044251d63
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_iota.cpp
@@ -0,0 +1,42 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_iota;
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota_c<0>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota_c<1>, mp_list<mp_size_t<0>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota_c<2>, mp_list<mp_size_t<0>, mp_size_t<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota_c<3>, mp_list<mp_size_t<0>, mp_size_t<1>, mp_size_t<2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota_c<4>, mp_list<mp_size_t<0>, mp_size_t<1>, mp_size_t<2>, mp_size_t<3>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_size_t<0>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_size_t<1>>, mp_list<mp_size_t<0>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_size_t<2>>, mp_list<mp_size_t<0>, mp_size_t<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_size_t<3>>, mp_list<mp_size_t<0>, mp_size_t<1>, mp_size_t<2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_size_t<4>>, mp_list<mp_size_t<0>, mp_size_t<1>, mp_size_t<2>, mp_size_t<3>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_int<0>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_int<1>>, mp_list<mp_int<0>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_int<2>>, mp_list<mp_int<0>, mp_int<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_int<3>>, mp_list<mp_int<0>, mp_int<1>, mp_int<2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iota<mp_int<4>>, mp_list<mp_int<0>, mp_int<1>, mp_int<2>, mp_int<3>>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_is_list.cpp b/src/boost/libs/mp11/test/mp_is_list.cpp
new file mode 100644
index 000000000..62e602ea6
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_is_list.cpp
@@ -0,0 +1,50 @@
+
+// Copyright 2017 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/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_is_list;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<int>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<char[]>, mp_false>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<mp_list<>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<mp_list<void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<mp_list<void, void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<mp_list<void, void, void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<mp_list<void, void, void, void>>, mp_true>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::tuple<>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::tuple<void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::tuple<void, void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::tuple<void, void, void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::tuple<void, void, void, void>>, mp_true>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_list<std::pair<void, void>>, mp_true>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_is_map.cpp b/src/boost/libs/mp11/test/mp_is_map.cpp
new file mode 100644
index 000000000..980d14082
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_is_map.cpp
@@ -0,0 +1,59 @@
+
+// Copyright 2017 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_is_map;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<void>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<void>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<void>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<mp_list<>>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::tuple<>>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<mp_list<int>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::tuple<int>>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<std::pair<int, int const>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::pair<int, int const>>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<std::pair<int, int const>, std::pair<long, long const>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::pair<int, int const>, std::pair<long, long const>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::pair<std::pair<int, int const>, std::pair<long, long const>>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<std::pair<int, int const>, std::pair<int, long const>>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::pair<int, int const>, std::pair<int, long const>>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::pair<std::pair<int, int const>, std::pair<int, long const>>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::tuple<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<mp_list<mp_list<int>, mp_list<long, long>, mp_list<int, long long, long long>>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<mp_list<int>, mp_list<long, long>, mp_list<int, long long, long long>>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_map<std::tuple<std::tuple<int>, std::pair<long, long>, std::tuple<int, long long, long long>>>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_is_set.cpp b/src/boost/libs/mp11/test/mp_is_set.cpp
new file mode 100644
index 000000000..8657dc45d
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_is_set.cpp
@@ -0,0 +1,73 @@
+
+// Copyright 2017 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_is_set;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<int>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<char[]>, mp_false>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, void, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, void, void, void>>, mp_false>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, int>>, mp_false>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, char[]>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, char[], void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, char[], int>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<mp_list<void, int, char[], char[]>>, mp_false>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, void, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, void, void, void>>, mp_false>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, int>>, mp_false>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, char[]>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, char[], void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, char[], int>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::tuple<void, int, char[], char[]>>, mp_false>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::pair<void, void>>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::pair<void, int>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::pair<int, void>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_is_set<std::pair<int, int>>, mp_false>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_iterate.cpp b/src/boost/libs/mp11/test/mp_iterate.cpp
new file mode 100644
index 000000000..a0d1cb269
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_iterate.cpp
@@ -0,0 +1,68 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <cstddef>
+
+struct X1 {};
+struct X2 { using first_type = double; using next_type = X1; };
+struct X3 { using first_type = float; using next_type = X2; };
+struct X4 { using first_type = int; using next_type = X3; };
+
+template<class T> using first_type = typename T::first_type;
+template<class T> using next_type = typename T::next_type;
+
+template<class T1, class T2> struct cons {};
+
+template<class T1, class T2> struct cons2
+{
+    using first_type = T1;
+    using next_type = T2;
+};
+
+using boost::mp11::mp_reverse_fold;
+using boost::mp11::mp_iterate;
+using boost::mp11::mp_first;
+using boost::mp11::mp_second;
+using boost::mp11::mp_rest;
+
+template<class L1> void test()
+{
+    using R1 = mp_iterate<L1, mp_first, mp_rest>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<L1, R1>));
+
+    using V2 = mp_reverse_fold<L1, void, cons>;
+    using R2 = mp_iterate<V2, mp_first, mp_second>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<L1, R2>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+    using V3 = mp_reverse_fold<L1, void, cons2>;
+    using R3 = mp_iterate<V3, first_type, next_type>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<L1, R3>));
+
+#endif
+}
+
+int main()
+{
+    using boost::mp11::mp_list;
+
+    test< mp_list<> >();
+    test< mp_list<int> >();
+    test< mp_list<int, void> >();
+    test< mp_list<int, void, float> >();
+    test< mp_list<int, void, float, double> >();
+
+    using boost::mp11::mp_identity_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iterate<X4, mp_identity_t, next_type>, mp_list<X4, X3, X2, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_iterate<X4, first_type, next_type>, mp_list<int, float, double>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_less.cpp b/src/boost/libs/mp11/test/mp_less.cpp
new file mode 100644
index 000000000..0e72faf8b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_less.cpp
@@ -0,0 +1,68 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<0>, mp_int<-1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<0>, mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<0>, mp_int<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<0>, mp_int<2>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<-1>, mp_int<-2>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<-1>, mp_int<-1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<-1>, mp_int<0>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<-1>, mp_int<1>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<1>, mp_int<-1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<1>, mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<1>, mp_int<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<1>, mp_int<2>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_size_t<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_size_t<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_size_t<2>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_size_t<3>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<1>, mp_size_t<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<1>, mp_size_t<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<1>, mp_size_t<2>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<1>, mp_size_t<3>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<2>, mp_size_t<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<2>, mp_size_t<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<2>, mp_size_t<2>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<2>, mp_size_t<3>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_int<-1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_size_t<0>, mp_int<1>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<-1>, mp_size_t<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<0>, mp_size_t<1>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<1>, mp_size_t<1>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_less<mp_int<2>, mp_size_t<1>>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_list_c.cpp b/src/boost/libs/mp11/test/mp_list_c.cpp
new file mode 100644
index 000000000..d6130ebfc
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_list_c.cpp
@@ -0,0 +1,27 @@
+
+// Copyright 2017 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/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_int;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_list_c<int>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_list_c<int, 1>, mp_list<mp_int<1>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_list_c<int, 1, 3>, mp_list<mp_int<1>, mp_int<3>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_list_c<int, 1, 3, 5>, mp_list<mp_int<1>, mp_int<3>, mp_int<5>>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_contains.cpp b/src/boost/libs/mp11/test/mp_map_contains.cpp
new file mode 100644
index 000000000..777b5c8aa
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_contains.cpp
@@ -0,0 +1,51 @@
+
+// Copyright 2016 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_contains;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<>, int>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<std::pair<int, int const>, std::pair<long, long const>>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<std::pair<int, int const>, std::pair<long, long const>>, int>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<std::pair<int, int const>, std::pair<long, long const>>, long>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, int>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, long>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::pair<std::pair<int, int const>, std::pair<long, long const>>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::pair<std::pair<int, int const>, std::pair<long, long const>>, int>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::pair<std::pair<int, int const>, std::pair<long, long const>>, long>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, int>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, long>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, long long>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, char>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, int>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, long>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_contains<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, long long>, mp_true>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_erase.cpp b/src/boost/libs/mp11/test/mp_map_erase.cpp
new file mode 100644
index 000000000..db0c691f5
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_erase.cpp
@@ -0,0 +1,60 @@
+
+// Copyright 2016, 2017 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_erase;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<mp_list<>, void>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<std::tuple<>, int>, std::tuple<>>));
+
+    {
+        using M = mp_list<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, char>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, int>, mp_list<std::pair<long, long const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long>, mp_list<std::pair<int, int const>>>));
+    }
+
+    {
+        using M = std::tuple<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, char>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, int>, std::tuple<std::pair<long, long const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long>, std::tuple<std::pair<int, int const>>>));
+    }
+
+    {
+        using M = mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, char>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, int>, mp_list<mp_list<long, long>, mp_list<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long>, mp_list<mp_list<int>, mp_list<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long long>, mp_list<mp_list<int>, mp_list<long, long>>>));
+    }
+
+    {
+        using M = std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, char>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, int>, std::tuple<std::pair<long, long>, std::tuple<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long>, std::tuple<mp_list<int>, std::tuple<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_erase<M, long long>, std::tuple<mp_list<int>, std::pair<long, long>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_find.cpp b/src/boost/libs/mp11/test/mp_map_find.cpp
new file mode 100644
index 000000000..2bd614dac
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_find.cpp
@@ -0,0 +1,48 @@
+
+// Copyright 2016 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_find;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<>, int>, void>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<std::pair<int, int const>, std::pair<long, long const>>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<std::pair<int, int const>, std::pair<long, long const>>, int>, std::pair<int, int const>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<std::pair<int, int const>, std::pair<long, long const>>, long>, std::pair<long, long const>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, int>, std::pair<int, int const>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<std::pair<int, int const>, std::pair<long, long const>>, long>, std::pair<long, long const>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::pair<std::pair<int, int const>, std::pair<long, long const>>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::pair<std::pair<int, int const>, std::pair<long, long const>>, int>, std::pair<int, int const>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::pair<std::pair<int, int const>, std::pair<long, long const>>, long>, std::pair<long, long const>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, int>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, long>, mp_list<long, long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>, long long>, mp_list<long long, long long, long long>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, char>, void>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, int>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, long>, std::pair<long, long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_find<std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>, long long>, std::tuple<long long, long long, long long>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_insert.cpp b/src/boost/libs/mp11/test/mp_map_insert.cpp
new file mode 100644
index 000000000..11920a7a3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_insert.cpp
@@ -0,0 +1,66 @@
+
+// Copyright 2016 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_insert;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_push_back;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<mp_list<>, mp_list<void>>, mp_list<mp_list<void>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<std::tuple<>, std::tuple<int>>, std::tuple<std::tuple<int>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<std::tuple<>, std::pair<int, float>>, std::tuple<std::pair<int, float>>>));
+
+    {
+        using M = mp_list<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<int>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<long, float>>, M>));
+    }
+
+    {
+        using M = std::tuple<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<int>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<long, float>>, M>));
+    }
+
+    {
+        using M = mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::tuple<int>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<long, float>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<long long, float, double>>, M>));
+    }
+
+    {
+        using M = std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::tuple<int>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, std::pair<long, float>>, M>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_insert<M, mp_list<long long, float, double>>, M>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_keys.cpp b/src/boost/libs/mp11/test/mp_map_keys.cpp
new file mode 100644
index 000000000..aa9eb6475
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_keys.cpp
@@ -0,0 +1,37 @@
+
+// Copyright 2017 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_keys;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<mp_list<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::tuple<>>, std::tuple<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<mp_list<std::pair<int, int const>>>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::tuple<std::pair<int, int const>>>, std::tuple<int>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<mp_list<std::pair<int, int const>, std::pair<long, long const>>>, mp_list<int, long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::tuple<std::pair<int, int const>, std::pair<long, long const>>>, std::tuple<int, long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::pair<std::pair<int, int const>, std::pair<long, long const>>>, std::pair<int, long>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>>, mp_list<int, long, long long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::tuple<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>>, std::tuple<int, long, long long>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_keys<std::tuple<std::tuple<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>>, std::tuple<int, long, long long>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_replace.cpp b/src/boost/libs/mp11/test/mp_map_replace.cpp
new file mode 100644
index 000000000..c68b05923
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_replace.cpp
@@ -0,0 +1,66 @@
+
+// Copyright 2016 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_map_replace;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_push_back;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<mp_list<>, mp_list<void>>, mp_list<mp_list<void>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<std::tuple<>, std::tuple<int>>, std::tuple<std::tuple<int>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<std::tuple<>, std::pair<int, float>>, std::tuple<std::pair<int, float>>>));
+
+    {
+        using M = mp_list<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<int>>, mp_list<mp_list<int>, std::pair<long, long const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<long, float>>, mp_list<std::pair<int, int const>, std::pair<long, float>>>));
+    }
+
+    {
+        using M = std::tuple<std::pair<int, int const>, std::pair<long, long const>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<int>>, std::tuple<mp_list<int>, std::pair<long, long const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<long, float>>, std::tuple<std::pair<int, int const>, std::pair<long, float>>>));
+    }
+
+    {
+        using M = mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::tuple<int>>, mp_list<std::tuple<int>, mp_list<long, long>, mp_list<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<long, float>>, mp_list<mp_list<int>, std::pair<long, float>, mp_list<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<long long, float, double>>, mp_list<mp_list<int>, mp_list<long, long>, mp_list<long long, float, double>>>));
+    }
+
+    {
+        using M = std::tuple<mp_list<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<char>>, mp_push_back<M, mp_list<char>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<char, char const>>, mp_push_back<M, std::pair<char, char const>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::tuple<int>>, std::tuple<std::tuple<int>, std::pair<long, long>, std::tuple<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, std::pair<long, float>>, std::tuple<mp_list<int>, std::pair<long, float>, std::tuple<long long, long long, long long>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_map_replace<M, mp_list<long long, float, double>>, std::tuple<mp_list<int>, std::pair<long, long>, mp_list<long long, float, double>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_update.cpp b/src/boost/libs/mp11/test/mp_map_update.cpp
new file mode 100644
index 000000000..24e7e775f
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_update.cpp
@@ -0,0 +1,48 @@
+
+// Copyright 2016, 2017 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+using boost::mp11::mp_int;
+
+template<class T, class U> using inc = mp_int<U::value + 1>;
+
+int main()
+{
+    using boost::mp11::mp_map_update;
+    using boost::mp11::mp_list;
+
+    using M1 = mp_list<>;
+
+    using M2 = mp_map_update< M1, std::pair<char, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M2, mp_list<std::pair<char, mp_int<0>>>>));
+
+    using M3 = mp_map_update< M2, std::pair<char, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M3, mp_list<std::pair<char, mp_int<1>>>>));
+
+    using M4 = mp_map_update< M3, std::pair<int, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M4, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>>>));
+
+    using M5 = mp_map_update< M4, std::pair<long, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M5, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<0>>>>));
+
+    using M6 = mp_map_update< M5, std::pair<long, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M6, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<1>>>>));
+
+    using M7 = mp_map_update< M6, std::pair<char, mp_int<0>>, inc >;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M7, mp_list<std::pair<char, mp_int<2>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<1>>>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_map_update_q.cpp b/src/boost/libs/mp11/test/mp_map_update_q.cpp
new file mode 100644
index 000000000..7aae6ddbf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_map_update_q.cpp
@@ -0,0 +1,51 @@
+
+// Copyright 2016, 2017 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/map.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+using boost::mp11::mp_int;
+
+struct Q_inc
+{
+    template<class T, class U> using fn = mp_int<U::value + 1>;
+};
+
+int main()
+{
+    using boost::mp11::mp_map_update_q;
+    using boost::mp11::mp_list;
+
+    using M1 = mp_list<>;
+
+    using M2 = mp_map_update_q<M1, std::pair<char, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M2, mp_list<std::pair<char, mp_int<0>>>>));
+
+    using M3 = mp_map_update_q<M2, std::pair<char, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M3, mp_list<std::pair<char, mp_int<1>>>>));
+
+    using M4 = mp_map_update_q<M3, std::pair<int, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M4, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>>>));
+
+    using M5 = mp_map_update_q<M4, std::pair<long, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M5, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<0>>>>));
+
+    using M6 = mp_map_update_q<M5, std::pair<long, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M6, mp_list<std::pair<char, mp_int<1>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<1>>>>));
+
+    using M7 = mp_map_update_q<M6, std::pair<char, mp_int<0>>, Q_inc>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<M7, mp_list<std::pair<char, mp_int<2>>, std::pair<int, mp_int<0>>, std::pair<long, mp_int<1>>>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_max.cpp b/src/boost/libs/mp11/test/mp_max.cpp
new file mode 100644
index 000000000..577d26bce
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_max.cpp
@@ -0,0 +1,31 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_max;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max<mp_int<1>>, mp_int<1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max<mp_int<2>, mp_int<1>, mp_int<2>, mp_int<3>>, mp_int<3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max<mp_int<-1>, mp_size_t<1>, mp_int<-2>, mp_size_t<2>>, mp_size_t<2>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_max_element.cpp b/src/boost/libs/mp11/test/mp_max_element.cpp
new file mode 100644
index 000000000..18550290b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_max_element.cpp
@@ -0,0 +1,55 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+template<class T, class U> using sizeof_less = mp_bool<(sizeof(T) < sizeof(U))>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_max_element;
+
+    {
+        using L1 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L1, sizeof_less>, void>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L2, sizeof_less>, char[4]>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L3, sizeof_less>, char[4]>));
+    }
+
+    {
+        using L1 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L1, sizeof_less>, void>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L2, sizeof_less>, char[4]>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element<L3, sizeof_less>, char[4]>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_max_element_q.cpp b/src/boost/libs/mp11/test/mp_max_element_q.cpp
new file mode 100644
index 000000000..36a79c4ce
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_max_element_q.cpp
@@ -0,0 +1,58 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+struct Q_sizeof_less
+{
+    template<class T, class U> using fn = mp_bool<(sizeof(T) < sizeof(U))>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_max_element_q;
+
+    {
+        using L1 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L1, Q_sizeof_less>, void>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L2, Q_sizeof_less>, char[4]>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L3, Q_sizeof_less>, char[4]>));
+    }
+
+    {
+        using L1 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L1, Q_sizeof_less>, void>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L2, Q_sizeof_less>, char[4]>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_max_element_q<L3, Q_sizeof_less>, char[4]>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_min.cpp b/src/boost/libs/mp11/test/mp_min.cpp
new file mode 100644
index 000000000..a23209842
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_min.cpp
@@ -0,0 +1,31 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_min;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min<mp_int<1>>, mp_int<1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min<mp_int<2>, mp_int<1>, mp_int<2>, mp_int<3>>, mp_int<1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min<mp_int<-1>, mp_size_t<1>, mp_int<-2>, mp_size_t<2>>, mp_int<-2>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_min_element.cpp b/src/boost/libs/mp11/test/mp_min_element.cpp
new file mode 100644
index 000000000..3a4451e09
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_min_element.cpp
@@ -0,0 +1,55 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+template<class T, class U> using sizeof_less = mp_bool<(sizeof(T) < sizeof(U))>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_min_element;
+
+    {
+        using L1 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L1, sizeof_less>, void>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L2, sizeof_less>, char[1]>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L3, sizeof_less>, char[1]>));
+    }
+
+    {
+        using L1 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L1, sizeof_less>, void>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L2, sizeof_less>, char[1]>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element<L3, sizeof_less>, char[1]>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_min_element_q.cpp b/src/boost/libs/mp11/test/mp_min_element_q.cpp
new file mode 100644
index 000000000..b1a09202b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_min_element_q.cpp
@@ -0,0 +1,58 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+struct Q_sizeof_less
+{
+    template<class T, class U> using fn = mp_bool<(sizeof(T) < sizeof(U))>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_min_element_q;
+
+    {
+        using L1 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L1, Q_sizeof_less>, void>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L2, Q_sizeof_less>, char[1]>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L3, Q_sizeof_less>, char[1]>));
+    }
+
+    {
+        using L1 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L1, Q_sizeof_less>, void>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L2, Q_sizeof_less>, char[1]>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_min_element_q<L3, Q_sizeof_less>, char[1]>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_none_of.cpp b/src/boost/libs/mp11/test/mp_none_of.cpp
new file mode 100644
index 000000000..c0bd37e9c
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_none_of.cpp
@@ -0,0 +1,72 @@
+
+// Copyright 2015, 2016 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_none_of;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L1, std::is_const>, mp_true>));
+
+        using L2 = mp_list<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_const>, mp_false>));
+
+        using L3 = mp_list<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_const>, mp_false>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L1, std::is_const>, mp_true>));
+
+        using L2 = std::tuple<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_const>, mp_false>));
+
+        using L3 = std::tuple<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_const>, mp_false>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L2, std::is_const>, mp_false>));
+
+        using L3 = std::pair<X1 const, X1 const>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_volatile>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of<L3, std::is_const>, mp_false>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_none_of_q.cpp b/src/boost/libs/mp11/test/mp_none_of_q.cpp
new file mode 100644
index 000000000..dd4ba636f
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_none_of_q.cpp
@@ -0,0 +1,74 @@
+
+// Copyright 2015, 2016, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_none_of_q;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L1, mp_quote<std::is_const>>, mp_true>));
+
+        using L2 = mp_list<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_const>>, mp_false>));
+
+        using L3 = mp_list<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_const>>, mp_false>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L1, mp_quote<std::is_const>>, mp_true>));
+
+        using L2 = std::tuple<X1, X1 const, X1, X1, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_const>>, mp_false>));
+
+        using L3 = std::tuple<X1 const, X1 const, X1, X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_const>>, mp_false>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L2, mp_quote<std::is_const>>, mp_false>));
+
+        using L3 = std::pair<X1 const, X1 const>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_volatile>>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_none_of_q<L3, mp_quote<std::is_const>>, mp_false>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_not_fn.cpp b/src/boost/libs/mp11/test/mp_not_fn.cpp
new file mode 100644
index 000000000..808e0ab11
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_not_fn.cpp
@@ -0,0 +1,36 @@
+
+// Copyright 2019 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/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class T> using is_const_ = std::is_const<T>;
+
+struct Q_is_const
+{
+    template<class T> using fn = std::is_const<T>;
+};
+
+int main()
+{
+    using boost::mp11::mp_not_fn;
+    using boost::mp11::mp_not_fn_q;
+
+    BOOST_TEST_TRAIT_TRUE((mp_not_fn<std::is_const>::fn<void>));
+    BOOST_TEST_TRAIT_FALSE((mp_not_fn<std::is_const>::fn<void const>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_not_fn<is_const_>::fn<void>));
+    BOOST_TEST_TRAIT_FALSE((mp_not_fn<is_const_>::fn<void const>));
+
+    BOOST_TEST_TRAIT_TRUE((mp_not_fn_q<Q_is_const>::fn<void>));
+    BOOST_TEST_TRAIT_FALSE((mp_not_fn_q<Q_is_const>::fn<void const>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_nth_element.cpp b/src/boost/libs/mp11/test/mp_nth_element.cpp
new file mode 100644
index 000000000..8a077d7cc
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_nth_element.cpp
@@ -0,0 +1,72 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_nth_element;
+    using boost::mp11::mp_nth_element_c;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_sort;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_at_c;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_rename;
+
+    {
+        using L1 = mp_list_c<int, 7, 1, 11, 3, 2, 2, 4>;
+        using L2 = mp_sort<L1, mp_less>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 0, mp_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 1, mp_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 2, mp_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 3, mp_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 4, mp_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 5, mp_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 6, mp_less>, mp_at_c<L2, 6>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<0>, mp_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<1>, mp_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<2>, mp_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<3>, mp_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<4>, mp_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<5>, mp_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<6>, mp_less>, mp_at_c<L2, 6>>));
+    }
+
+    {
+        using L1 = mp_rename<mp_list_c<int, 7, 1, 11, 3, 2, 2, 4>, std::tuple>;
+        using L2 = mp_sort<L1, mp_less>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 0, mp_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 1, mp_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 2, mp_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 3, mp_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 4, mp_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 5, mp_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_c<L1, 6, mp_less>, mp_at_c<L2, 6>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<0>, mp_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<1>, mp_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<2>, mp_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<3>, mp_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<4>, mp_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<5>, mp_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element<L1, mp_size_t<6>, mp_less>, mp_at_c<L2, 6>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_nth_element_q.cpp b/src/boost/libs/mp11/test/mp_nth_element_q.cpp
new file mode 100644
index 000000000..0c6a333fe
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_nth_element_q.cpp
@@ -0,0 +1,59 @@
+
+// Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_nth_element_q;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_sort_q;
+    using boost::mp11::mp_less;
+    using boost::mp11::mp_at_c;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_rename;
+    using boost::mp11::mp_quote;
+
+    using Q_less = mp_quote<mp_less>;
+
+    {
+        using L1 = mp_list_c<int, 7, 1, 11, 3, 2, 2, 4>;
+        using L2 = mp_sort_q<L1, Q_less>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<0>, Q_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<1>, Q_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<2>, Q_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<3>, Q_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<4>, Q_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<5>, Q_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<6>, Q_less>, mp_at_c<L2, 6>>));
+    }
+
+    {
+        using L1 = mp_rename<mp_list_c<int, 7, 1, 11, 3, 2, 2, 4>, std::tuple>;
+        using L2 = mp_sort_q<L1, Q_less>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<0>, Q_less>, mp_at_c<L2, 0>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<1>, Q_less>, mp_at_c<L2, 1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<2>, Q_less>, mp_at_c<L2, 2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<3>, Q_less>, mp_at_c<L2, 3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<4>, Q_less>, mp_at_c<L2, 4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<5>, Q_less>, mp_at_c<L2, 5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_nth_element_q<L1, mp_size_t<6>, Q_less>, mp_at_c<L2, 6>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_or.cpp b/src/boost/libs/mp11/test/mp_or.cpp
new file mode 100644
index 000000000..f88097ebf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_or.cpp
@@ -0,0 +1,73 @@
+
+// Copyright 2015-2017 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/function.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_or;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<-7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<7>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_true, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<0>>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<5>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<-4>, void>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<7>, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<4>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_true, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_true, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_true, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_true, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false, mp_true, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false, mp_false, mp_true>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_false, mp_false, mp_false, mp_false>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<1>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<2>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<0>, mp_int<3>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<0>, mp_int<0>, mp_int<4>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_int<0>, mp_int<0>, mp_int<0>, mp_int<0>, mp_int<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<1>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<2>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<0>, mp_size_t<3>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<0>, mp_size_t<0>, mp_size_t<4>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_size_t<0>, mp_size_t<0>, mp_size_t<0>, mp_size_t<0>>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_int<0>, mp_false, mp_size_t<141>, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_or<mp_size_t<0>, mp_int<0>, mp_false>, mp_false>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_partial_sum.cpp b/src/boost/libs/mp11/test/mp_partial_sum.cpp
new file mode 100644
index 000000000..75366b0f8
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_partial_sum.cpp
@@ -0,0 +1,88 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <cstddef>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+template<class T1, class T2> struct F {};
+
+struct Q
+{
+    template<class T1, class T2> struct fn {};
+};
+
+int main()
+{
+    using boost::mp11::mp_partial_sum;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_list_c;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_plus;
+    using boost::mp11::mp_rename;
+    using boost::mp11::mp_partial_sum_q;
+    using boost::mp11::mp_quote;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list<>, void, F >, mp_list<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list<X1>, void, F >, mp_list< F<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list<X1, X2>, void, F >, mp_list< F<void, X1>, F<F<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list<X1, X2, X3>, void, F >, mp_list< F<void, X1>, F<F<void, X1>, X2>, F<F<F<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list_c<int, 7, 7, 2>, mp_int<0>, mp_plus >, mp_list< mp_int<7>, mp_int<14>, mp_int<16> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_list_c<std::size_t, 7, 7, 2>, mp_size_t<0>, mp_plus >, mp_list< mp_size_t<7>, mp_size_t<14>, mp_size_t<16> > >));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<>, void, mp_quote<F> >, mp_list<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1>, void, mp_quote<F> >, mp_list< F<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1, X2>, void, mp_quote<F> >, mp_list< F<void, X1>, F<F<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1, X2, X3>, void, mp_quote<F> >, mp_list< F<void, X1>, F<F<void, X1>, X2>, F<F<F<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<>, void, Q >, mp_list<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1>, void, Q >, mp_list< Q::fn<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1, X2>, void, Q >, mp_list< Q::fn<void, X1>, Q::fn<Q::fn<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list<X1, X2, X3>, void, Q >, mp_list< Q::fn<void, X1>, Q::fn<Q::fn<void, X1>, X2>, Q::fn<Q::fn<Q::fn<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list_c<int, 7, 7, 2>, mp_int<0>, mp_quote<mp_plus> >, mp_list< mp_int<7>, mp_int<14>, mp_int<16> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_list_c<std::size_t, 7, 7, 2>, mp_size_t<0>, mp_quote<mp_plus> >, mp_list< mp_size_t<7>, mp_size_t<14>, mp_size_t<16> > >));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< std::tuple<>, void, F >, std::tuple<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< std::tuple<X1>, void, F >, std::tuple< F<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< std::tuple<X1, X2>, void, F >, std::tuple< F<void, X1>, F<F<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< std::tuple<X1, X2, X3>, void, F >, std::tuple< F<void, X1>, F<F<void, X1>, X2>, F<F<F<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_rename<mp_list_c<int, 7, 7, 2>, std::tuple>, mp_int<0>, mp_plus >, std::tuple< mp_int<7>, mp_int<14>, mp_int<16> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum< mp_rename<mp_list_c<std::size_t, 7, 7, 2>, std::tuple>, mp_size_t<0>, mp_plus >, std::tuple< mp_size_t<7>, mp_size_t<14>, mp_size_t<16> > >));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<>, void, mp_quote<F> >, std::tuple<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1>, void, mp_quote<F> >, std::tuple< F<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1, X2>, void, mp_quote<F> >, std::tuple< F<void, X1>, F<F<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1, X2, X3>, void, mp_quote<F> >, std::tuple< F<void, X1>, F<F<void, X1>, X2>, F<F<F<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<>, void, Q >, std::tuple<> >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1>, void, Q >, std::tuple< Q::fn<void, X1> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1, X2>, void, Q >, std::tuple< Q::fn<void, X1>, Q::fn<Q::fn<void, X1>, X2> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< std::tuple<X1, X2, X3>, void, Q >, std::tuple< Q::fn<void, X1>, Q::fn<Q::fn<void, X1>, X2>, Q::fn<Q::fn<Q::fn<void, X1>, X2>, X3> > >));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_rename<mp_list_c<int, 7, 7, 2>, std::tuple>, mp_int<0>, mp_quote<mp_plus> >, std::tuple< mp_int<7>, mp_int<14>, mp_int<16> > >));
+        BOOST_TEST_TRAIT_TRUE((std::is_same< mp_partial_sum_q< mp_rename<mp_list_c<std::size_t, 7, 7, 2>, std::tuple>, mp_size_t<0>, mp_quote<mp_plus> >, std::tuple< mp_size_t<7>, mp_size_t<14>, mp_size_t<16> > >));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_partition.cpp b/src/boost/libs/mp11/test/mp_partition.cpp
new file mode 100644
index 000000000..8dc1ac2b1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_partition.cpp
@@ -0,0 +1,50 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_partition;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L1, std::is_const>, mp_list<L1, L1>>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_volatile>, mp_list<L1, L2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_const>, mp_list<mp_list<X1 const, X2 const>, mp_list<X1, X1*, X2*, X3*>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_pointer>, mp_list<mp_list<X1*, X2*, X3*>, mp_list<X1, X1 const, X2 const>>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L1, std::is_const>, std::tuple<L1, L1>>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_volatile>, std::tuple<L1, L2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_const>, std::tuple<std::tuple<X1 const, X2 const>, std::tuple<X1, X1*, X2*, X3*>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition<L2, std::is_pointer>, std::tuple<std::tuple<X1*, X2*, X3*>, std::tuple<X1, X1 const, X2 const>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_partition_q.cpp b/src/boost/libs/mp11/test/mp_partition_q.cpp
new file mode 100644
index 000000000..fc04c52d1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_partition_q.cpp
@@ -0,0 +1,52 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_partition_q;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L1, mp_quote<std::is_const>>, mp_list<L1, L1>>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_volatile>>, mp_list<L1, L2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_const>>, mp_list<mp_list<X1 const, X2 const>, mp_list<X1, X1*, X2*, X3*>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_pointer>>, mp_list<mp_list<X1*, X2*, X3*>, mp_list<X1, X1 const, X2 const>>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L1, mp_quote<std::is_const>>, std::tuple<L1, L1>>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_volatile>>, std::tuple<L1, L2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_const>>, std::tuple<std::tuple<X1 const, X2 const>, std::tuple<X1, X1*, X2*, X3*>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_partition_q<L2, mp_quote<std::is_pointer>>, std::tuple<std::tuple<X1*, X2*, X3*>, std::tuple<X1, X1 const, X2 const>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_plus.cpp b/src/boost/libs/mp11/test/mp_plus.cpp
new file mode 100644
index 000000000..06c05d2c0
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_plus.cpp
@@ -0,0 +1,32 @@
+
+// Copyright 2015-2017 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/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class T, T N> using integral = std::integral_constant<T, N>;
+
+int main()
+{
+    using boost::mp11::mp_plus;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<>, integral<int, 0>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<char, 1>>, integral<int, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<short, 2>>, integral<int, 2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<int, 3>>, integral<int, 3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<unsigned, 4>>, integral<unsigned, 4>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<char, 1>, integral<char, 2>>, integral<int, 3>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<short, 1>, integral<short, 2>, integral<short, 3>>, integral<int, 6>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_plus<integral<int, 1>, integral<int, 2>, integral<int, 3>, integral<long, 4>>, integral<long, 10>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_pop_back.cpp b/src/boost/libs/mp11/test/mp_pop_back.cpp
new file mode 100644
index 000000000..554da9ed1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_pop_back.cpp
@@ -0,0 +1,49 @@
+
+// Copyright 2015, 2019 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_pop_back;
+
+    using L1 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_back<L1>, mp_list<>>));
+
+    using L2 = mp_list<float, void, int[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_back<L2>, mp_list<float, void>>));
+
+    using L3 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_back<L3>, std::tuple<>>));
+
+    using L4 = std::tuple<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_back<L4>, std::tuple<char>>));
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    int const N = 137;
+
+    using L6 = mp_iota_c<N>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_back<L6>, mp_iota_c<N-1>>));
+
+    using boost::mp11::mp_valid;
+
+    using L7 = mp_list<>;
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_pop_back, L7>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_pop_front.cpp b/src/boost/libs/mp11/test/mp_pop_front.cpp
new file mode 100644
index 000000000..f1ff16a50
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_pop_front.cpp
@@ -0,0 +1,39 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_pop_front;
+    using boost::mp11::mp_rest;
+
+    using L1 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_front<L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rest<L1>, mp_list<>>));
+
+    using L2 = mp_list<int[], void(), float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_front<L2>, mp_list<void(), float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rest<L2>, mp_list<void(), float>>));
+
+    using L3 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_front<L3>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rest<L3>, std::tuple<>>));
+
+    using L4 = std::tuple<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_pop_front<L4>, std::tuple<double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rest<L4>, std::tuple<double>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_power_set.cpp b/src/boost/libs/mp11/test/mp_power_set.cpp
new file mode 100644
index 000000000..250bfbb02
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_power_set.cpp
@@ -0,0 +1,33 @@
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_power_set;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< mp_list<> >, mp_list<mp_list<>> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< mp_list<X1> >, mp_list< mp_list<>, mp_list<X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< mp_list<X2, X1> >, mp_list< mp_list<>, mp_list<X1>, mp_list<X2>, mp_list<X2, X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< mp_list<X1, X1> >, mp_list< mp_list<>, mp_list<X1>, mp_list<X1>, mp_list<X1, X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< mp_list<X3, X2, X1> >, mp_list< mp_list<>, mp_list<X1>, mp_list<X2>, mp_list<X2, X1>, mp_list<X3>, mp_list<X3, X1>, mp_list<X3, X2>, mp_list<X3, X2, X1> > >));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< std::tuple<> >, std::tuple<std::tuple<>> >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< std::tuple<X1> >, std::tuple< std::tuple<>, std::tuple<X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< std::tuple<X2, X1> >, std::tuple< std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X2, X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< std::tuple<X1, X1> >, std::tuple< std::tuple<>, std::tuple<X1>, std::tuple<X1>, std::tuple<X1, X1> > >));
+    BOOST_TEST_TRAIT_TRUE((std::is_same< mp_power_set< std::tuple<X3, X2, X1> >, std::tuple< std::tuple<>, std::tuple<X1>, std::tuple<X2>, std::tuple<X2, X1>, std::tuple<X3>, std::tuple<X3, X1>, std::tuple<X3, X2>, std::tuple<X3, X2, X1> > >));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_product.cpp b/src/boost/libs/mp11/test/mp_product.cpp
new file mode 100644
index 000000000..3d3d2ad70
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_product.cpp
@@ -0,0 +1,68 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+struct Y1 {};
+
+struct Z1 {};
+struct Z2 {};
+
+template<class T1, class T2, class T3> struct F {};
+
+template<class T> struct F1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_product;
+    using boost::mp11::mp_product_q;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = std::tuple<X1, X2, X3>;
+        using L2 = mp_list<Y1>;
+        using L3 = std::pair<Z1, Z2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product<F, L1, L2, L3>, std::tuple<F<X1, Y1, Z1>, F<X1, Y1, Z2>, F<X2, Y1, Z1>, F<X2, Y1, Z2>, F<X3, Y1, Z1>, F<X3, Y1, Z2>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product_q<mp_quote<F>, L1, L2, L3>, std::tuple<F<X1, Y1, Z1>, F<X1, Y1, Z2>, F<X2, Y1, Z1>, F<X2, Y1, Z2>, F<X3, Y1, Z1>, F<X3, Y1, Z2>>>));
+    }
+
+    {
+        using L1 = std::tuple<X1, X2, X3>;
+        using L2 = mp_list<>;
+        using L3 = std::pair<Z1, Z2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product<F, L1, L2, L3>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product_q<mp_quote<F>, L1, L2, L3>, std::tuple<>>));
+    }
+
+    {
+        using L1 = std::tuple<X1, X2, X3>;
+        using L2 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product<F1, L1>, std::tuple<F1<X1>, F1<X2>, F1<X3>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product_q<mp_quote<F1>, L1>, std::tuple<F1<X1>, F1<X2>, F1<X3>>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product<F1, L2>, mp_list<F1<X1>, F1<X2>, F1<X3>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_product_q<mp_quote<F1>, L2>, mp_list<F1<X1>, F1<X2>, F1<X3>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_push_back.cpp b/src/boost/libs/mp11/test/mp_push_back.cpp
new file mode 100644
index 000000000..c74fb0315
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_push_back.cpp
@@ -0,0 +1,52 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_push_back;
+
+    using L1 = mp_list<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L1, char[1]>, mp_list<char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L1, char[1], char[2]>, mp_list<char[1], char[2]>>));
+
+    using L2 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L2>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L2, char[1]>, mp_list<void, char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L2, char[1], char[2]>, mp_list<void, char[1], char[2]>>));
+
+    using L3 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L3>, mp_list<int[], void, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L3, char[1]>, mp_list<int[], void, float, char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L3, char[1], char[2]>, mp_list<int[], void, float, char[1], char[2]>>));
+
+    using L4 = std::tuple<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L4>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L4, char>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L4, char, wchar_t>, std::tuple<char, wchar_t>>));
+
+    using L5 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L5>, std::tuple<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L5, char>, std::tuple<int, char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L5, char, wchar_t>, std::tuple<int, char, wchar_t>>));
+
+    using L6 = std::tuple<int, int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L6>, std::tuple<int, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L6, char>, std::tuple<int, int, char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_back<L6, char, wchar_t>, std::tuple<int, int, char, wchar_t>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_push_front.cpp b/src/boost/libs/mp11/test/mp_push_front.cpp
new file mode 100644
index 000000000..73fcc8b7d
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_push_front.cpp
@@ -0,0 +1,52 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_push_front;
+
+    using L1 = mp_list<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L1, char[1]>, mp_list<char[1]>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L1, char[1], char[2]>, mp_list<char[1], char[2]>>));
+
+    using L2 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L2>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L2, char[1]>, mp_list<char[1], void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L2, char[1], char[2]>, mp_list<char[1], char[2], void>>));
+
+    using L3 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L3>, mp_list<int[], void, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L3, char[1]>, mp_list<char[1], int[], void, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L3, char[1], char[2]>, mp_list<char[1], char[2], int[], void, float>>));
+
+    using L4 = std::tuple<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L4>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L4, char>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L4, char, wchar_t>, std::tuple<char, wchar_t>>));
+
+    using L5 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L5>, std::tuple<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L5, char>, std::tuple<char, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L5, char, wchar_t>, std::tuple<char, wchar_t, int>>));
+
+    using L6 = std::tuple<int, int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L6>, std::tuple<int, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L6, char>, std::tuple<char, int, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_push_front<L6, char, wchar_t>, std::tuple<char, wchar_t, int, int>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_quote.cpp b/src/boost/libs/mp11/test/mp_quote.cpp
new file mode 100644
index 000000000..62bc915ba
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_quote.cpp
@@ -0,0 +1,68 @@
+
+// Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+using boost::mp11::mp_invoke_q;
+
+template<class...> struct X {};
+
+template<template<class...> class F, class... T> using Y = X<F<T>...>;
+
+template<class Q, class... T> using Z = X<mp_invoke_q<Q, T>...>;
+
+template<class T, class U> struct P {};
+
+template<class T, class U> using first = T;
+
+int main()
+{
+    using boost::mp11::mp_identity_t;
+    using boost::mp11::mp_quote;
+
+    {
+        using Q = mp_quote<mp_identity_t>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, int[]>, int[]>));
+    }
+
+    {
+        using Q = mp_quote<mp_identity_t>;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+        using R1 = Y<Q::fn, void, char, int>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, X<void, char, int>>));
+#endif
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 && BOOST_MP11_MSVC >= 1900 )
+        using R2 = Z<Q, void, char, int>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, X<void, char, int>>));
+#endif
+    }
+
+    {
+        using Q = mp_quote<P>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void, void>, P<void, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, char[], int[]>, P<char[], int[]>>));
+    }
+
+    {
+        using Q = mp_quote<first>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void, int>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, char[], int[]>, char[]>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_quote_trait.cpp b/src/boost/libs/mp11/test/mp_quote_trait.cpp
new file mode 100644
index 000000000..ab52bb949
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_quote_trait.cpp
@@ -0,0 +1,58 @@
+
+// Copyright 2015, 2017 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/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_identity;
+    using boost::mp11::mp_quote_trait;
+    using boost::mp11::mp_invoke_q;
+
+    {
+        using Q = mp_quote_trait<mp_identity>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<void>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<int[]>, int[]>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, int[]>, int[]>));
+    }
+
+    {
+        using Q = mp_quote_trait<std::add_pointer>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<void>, void*>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<int[]>, int(*)[]>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void>, void*>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, int[]>, int(*)[]>));
+    }
+
+    {
+        using Q = mp_quote_trait<std::add_const>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<void>, void const>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<Q::fn<int[]>, int const[]>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40900 )
+
+        // g++ 4.7, 4.8 have difficulties with preserving top-level const
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, void>, void const>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_invoke_q<Q, int[]>, int const[]>));
+
+#endif
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_remove.cpp b/src/boost/libs/mp11/test/mp_remove.cpp
new file mode 100644
index 000000000..87d9c6175
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_remove.cpp
@@ -0,0 +1,52 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_remove;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L1, void>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X1>, mp_list<X2, X3, X2, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X2>, mp_list<X1, X3, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X3>, mp_list<X1, X2, X2>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L1, void>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X1>, std::tuple<X2, X3, X2, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X2>, std::tuple<X1, X3, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove<L2, X3>, std::tuple<X1, X2, X2>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_remove_if.cpp b/src/boost/libs/mp11/test/mp_remove_if.cpp
new file mode 100644
index 000000000..883bf6cc7
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_remove_if.cpp
@@ -0,0 +1,67 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+using boost::mp11::mp_bool;
+
+template<class N> using is_odd = mp_bool<N::value % 2 != 0>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_remove_if;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L1, std::is_const>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_volatile>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_const>, mp_list<X1, X1*, X2*, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_pointer>, mp_list<X1, X1 const, X2 const>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L1, std::is_const>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_volatile>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_const>, std::tuple<X1, X1*, X2*, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if<L2, std::is_pointer>, std::tuple<X1, X1 const, X2 const>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 12;
+        using L1 = mp_iota_c<N>;
+
+        using R1 = mp_remove_if<L1, is_odd>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<mp_size_t<0>, mp_size_t<2>, mp_size_t<4>, mp_size_t<6>, mp_size_t<8>, mp_size_t<10>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_remove_if_q.cpp b/src/boost/libs/mp11/test/mp_remove_if_q.cpp
new file mode 100644
index 000000000..818cc63d7
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_remove_if_q.cpp
@@ -0,0 +1,72 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+using boost::mp11::mp_bool;
+
+struct Q_is_odd
+{
+    template<class N> using fn = mp_bool<N::value % 2 != 0>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_remove_if_q;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L1, mp_quote<std::is_const>>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_volatile>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_const>>, mp_list<X1, X1*, X2*, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_pointer>>, mp_list<X1, X1 const, X2 const>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L1, mp_quote<std::is_const>>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X2 const, X2*, X3*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_volatile>>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_const>>, std::tuple<X1, X1*, X2*, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_remove_if_q<L2, mp_quote<std::is_pointer>>, std::tuple<X1, X1 const, X2 const>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 12;
+        using L1 = mp_iota_c<N>;
+
+        using R1 = mp_remove_if_q<L1, Q_is_odd>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_list<mp_size_t<0>, mp_size_t<2>, mp_size_t<4>, mp_size_t<6>, mp_size_t<8>, mp_size_t<10>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_rename.cpp b/src/boost/libs/mp11/test/mp_rename.cpp
new file mode 100644
index 000000000..3ad751a44
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_rename.cpp
@@ -0,0 +1,146 @@
+
+//  Copyright 2015-2017 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+template<class... T> struct X {};
+template<class... T> using Y = X<T...>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_rename;
+    using boost::mp11::mp_apply;
+
+    using L1 = mp_list<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L1, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L1, std::tuple>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L1, X>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L1, Y>, Y<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L1>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L1>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L1>, Y<>>));
+
+    using L2 = mp_list<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L2, mp_list>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L2, std::tuple>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L2, X>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L2, Y>, Y<char>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L2>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L2>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L2>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L2>, Y<char>>));
+
+    using L3 = mp_list<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L3, mp_list>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L3, std::tuple>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L3, X>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L3, Y>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L3, std::pair>, std::pair<char, double>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L3>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L3>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L3>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L3>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::pair, L3>, std::pair<char, double>>));
+
+    using L4 = mp_list<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L4, mp_list>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L4, std::tuple>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L4, X>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L4, Y>, Y<int, char, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L4>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L4>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L4>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L4>, Y<int, char, float>>));
+
+    //
+
+    using L5 = std::tuple<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L5, mp_list>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L5, std::tuple>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L5, X>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L5, Y>, Y<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L5>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L5>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L5>, X<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L5>, Y<>>));
+
+    using L6 = std::tuple<char>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L6, mp_list>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L6, std::tuple>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L6, X>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L6, Y>, Y<char>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L6>, mp_list<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L6>, std::tuple<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L6>, X<char>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L6>, Y<char>>));
+
+    using L7 = std::tuple<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L7, mp_list>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L7, std::tuple>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L7, X>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L7, Y>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L7, std::pair>, std::pair<char, double>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L7>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L7>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L7>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L7>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::pair, L7>, std::pair<char, double>>));
+
+    using L8 = std::tuple<int, char, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L8, mp_list>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L8, std::tuple>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L8, X>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L8, Y>, Y<int, char, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L8>, mp_list<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L8>, std::tuple<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L8>, X<int, char, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L8>, Y<int, char, float>>));
+
+    //
+
+    using L9 = std::pair<char, double>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L9, mp_list>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L9, std::tuple>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L9, X>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L9, Y>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rename<L9, std::pair>, std::pair<char, double>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<mp_list, L9>, mp_list<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::tuple, L9>, std::tuple<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<X, L9>, X<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<Y, L9>, Y<char, double>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_apply<std::pair, L9>, std::pair<char, double>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_repeat.cpp b/src/boost/libs/mp11/test/mp_repeat.cpp
new file mode 100644
index 000000000..574b4fe85
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_repeat.cpp
@@ -0,0 +1,132 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_repeat;
+    using boost::mp11::mp_repeat_c;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_size_t;
+
+    using L1 = mp_list<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L1, 0>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L1, 1>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L1, 2>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L1, 3>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L1, 31>, mp_list<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L1, mp_false>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L1, mp_true>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L1, mp_int<2>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L1, mp_int<3>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L1, mp_size_t<31>>, mp_list<>>));
+
+    using L2 = mp_list<X1>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 0>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 1>, mp_list<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 2>, mp_list<X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 3>, mp_list<X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 4>, mp_list<X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 5>, mp_list<X1, X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L2, 6>, mp_list<X1, X1, X1, X1, X1, X1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_false>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_true>, mp_list<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_int<2>>, mp_list<X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_int<3>>, mp_list<X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_int<4>>, mp_list<X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_size_t<5>>, mp_list<X1, X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L2, mp_size_t<6>>, mp_list<X1, X1, X1, X1, X1, X1>>));
+
+    using L3 = mp_list<X1, X2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L3, 0>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L3, 1>, mp_list<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L3, 2>, mp_list<X1, X2, X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L3, 3>, mp_list<X1, X2, X1, X2, X1, X2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L3, mp_false>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L3, mp_true>, mp_list<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L3, mp_int<2>>, mp_list<X1, X2, X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L3, mp_size_t<3>>, mp_list<X1, X2, X1, X2, X1, X2>>));
+
+    //
+
+    using L4 = std::tuple<>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L4, 0>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L4, 1>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L4, 2>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L4, 3>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L4, 31>, std::tuple<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L4, mp_false>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L4, mp_true>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L4, mp_int<2>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L4, mp_int<3>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L4, mp_size_t<31>>, std::tuple<>>));
+
+    using L5 = std::tuple<X1>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 0>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 1>, std::tuple<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 2>, std::tuple<X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 3>, std::tuple<X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 4>, std::tuple<X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 5>, std::tuple<X1, X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L5, 6>, std::tuple<X1, X1, X1, X1, X1, X1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_false>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_true>, std::tuple<X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_int<2>>, std::tuple<X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_int<3>>, std::tuple<X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_int<4>>, std::tuple<X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_size_t<5>>, std::tuple<X1, X1, X1, X1, X1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L5, mp_size_t<6>>, std::tuple<X1, X1, X1, X1, X1, X1>>));
+
+    using L6 = std::tuple<X1, X2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L6, 0>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L6, 1>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L6, 2>, std::tuple<X1, X2, X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L6, 3>, std::tuple<X1, X2, X1, X2, X1, X2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L6, mp_false>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L6, mp_true>, std::tuple<X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L6, mp_int<2>>, std::tuple<X1, X2, X1, X2>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L6, mp_size_t<3>>, std::tuple<X1, X2, X1, X2, X1, X2>>));
+
+    //
+
+    using L7 = std::pair<X1, X2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat_c<L7, 1>, std::pair<X1, X2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_repeat<L7, mp_true>, std::pair<X1, X2>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace.cpp b/src/boost/libs/mp11/test/mp_replace.cpp
new file mode 100644
index 000000000..36a0ac6f2
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace.cpp
@@ -0,0 +1,61 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L1, void, int[]>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, void, int[]>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X1, int[]>, mp_list<int[], X2, X3, X2, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X2, int[]>, mp_list<X1, int[], X3, int[], X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X3, int[]>, mp_list<X1, X2, int[], X2, int[], int[]>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L1, void, int[]>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X2, X3, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, void, int[]>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X1, int[]>, std::tuple<int[], X2, X3, X2, X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X2, int[]>, std::tuple<X1, int[], X3, int[], X3, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X3, int[]>, std::tuple<X1, X2, int[], X2, int[], int[]>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, void, int[]>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X1, int[]>, std::pair<int[], X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace<L2, X2, int[]>, std::pair<X1, int[]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_at.cpp b/src/boost/libs/mp11/test/mp_replace_at.cpp
new file mode 100644
index 000000000..dfd66e114
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_at.cpp
@@ -0,0 +1,64 @@
+
+// Copyright 2015, 2017 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4804 ) // '>=': unsafe use of type 'bool' in operation
+#endif
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_at;
+    using boost::mp11::mp_int;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<0>, void>, mp_list<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<1>, void>, mp_list<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<2>, void>, mp_list<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<3>, void>, mp_list<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<4>, void>, mp_list<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<0>, void>, std::tuple<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<1>, void>, std::tuple<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<2>, void>, std::tuple<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<3>, void>, std::tuple<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_int<4>, void>, std::tuple<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_false, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at<L, mp_true, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_at_c.cpp b/src/boost/libs/mp11/test/mp_replace_at_c.cpp
new file mode 100644
index 000000000..5a5bd54b1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_at_c.cpp
@@ -0,0 +1,56 @@
+
+//  Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_at_c;
+
+    {
+        using L = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, mp_list<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, mp_list<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 2, void>, mp_list<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 3, void>, mp_list<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 4, void>, mp_list<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, std::tuple<void, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, std::tuple<X1, void, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 2, void>, std::tuple<X1, X2, void, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 3, void>, std::tuple<X1, X2, X3, void, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 4, void>, std::tuple<X1, X2, X3, X4, void>>));
+    }
+
+    {
+        using L = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 0, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_at_c<L, 1, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_front.cpp b/src/boost/libs/mp11/test/mp_replace_front.cpp
new file mode 100644
index 000000000..07156262e
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_front.cpp
@@ -0,0 +1,80 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_front;
+    using boost::mp11::mp_replace_first;
+
+    {
+        using L1 = mp_list<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L1, void>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L1, void>, mp_list<void>>));
+
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, mp_list<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, mp_list<void, X2>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L3, void>, mp_list<void, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L3, void>, mp_list<void, X2, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L4, void>, mp_list<void, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L4, void>, mp_list<void, X2, X3, X4>>));
+    }
+
+    {
+        using L1 = std::tuple<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L1, void>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L1, void>, std::tuple<void>>));
+
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, std::tuple<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, std::tuple<void, X2>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L3, void>, std::tuple<void, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L3, void>, std::tuple<void, X2, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L4, void>, std::tuple<void, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L4, void>, std::tuple<void, X2, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_front<L2, void>, std::pair<void, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_first<L2, void>, std::pair<void, X2>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_if.cpp b/src/boost/libs/mp11/test/mp_replace_if.cpp
new file mode 100644
index 000000000..98845d3f0
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_if.cpp
@@ -0,0 +1,57 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_if;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L1, std::is_const, void>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_volatile, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_const, void>, mp_list<X1, void, X1*, void, X1*, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_pointer, void>, mp_list<X1, X1 const, void, X1 const, void, void>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L1, std::is_const, void>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_volatile, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_const, void>, std::tuple<X1, void, X1*, void, X1*, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_pointer, void>, std::tuple<X1, X1 const, void, X1 const, void, void>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_volatile, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_const, void>, std::pair<void, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if<L2, std::is_pointer, void>, std::pair<X1 const, void>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_if_q.cpp b/src/boost/libs/mp11/test/mp_replace_if_q.cpp
new file mode 100644
index 000000000..a692673fc
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_if_q.cpp
@@ -0,0 +1,59 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_if_q;
+    using boost::mp11::mp_quote;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L1, mp_quote<std::is_const>, void>, L1>));
+
+        using L2 = mp_list<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_volatile>, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_const>, void>, mp_list<X1, void, X1*, void, X1*, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_pointer>, void>, mp_list<X1, X1 const, void, X1 const, void, void>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L1, mp_quote<std::is_const>, void>, L1>));
+
+        using L2 = std::tuple<X1, X1 const, X1*, X1 const, X1*, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_volatile>, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_const>, void>, std::tuple<X1, void, X1*, void, X1*, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_pointer>, void>, std::tuple<X1, X1 const, void, X1 const, void, void>>));
+    }
+
+    {
+        using L2 = std::pair<X1 const, X1*>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_volatile>, void>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_const>, void>, std::pair<void, X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_if_q<L2, mp_quote<std::is_pointer>, void>, std::pair<X1 const, void>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_second.cpp b/src/boost/libs/mp11/test/mp_replace_second.cpp
new file mode 100644
index 000000000..deaab1b24
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_second.cpp
@@ -0,0 +1,62 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_second;
+
+    {
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, mp_list<X1, void>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L3, void>, mp_list<X1, void, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L4, void>, mp_list<X1, void, X3, X4>>));
+    }
+
+    {
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, std::tuple<X1, void>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L3, void>, std::tuple<X1, void, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L4, void>, std::tuple<X1, void, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_second<L2, void>, std::pair<X1, void>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_replace_third.cpp b/src/boost/libs/mp11/test/mp_replace_third.cpp
new file mode 100644
index 000000000..c1b53b53b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_replace_third.cpp
@@ -0,0 +1,48 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_replace_third;
+
+    {
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L3, void>, mp_list<X1, X2, void>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L4, void>, mp_list<X1, X2, void, X4>>));
+    }
+
+    {
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L3, void>, std::tuple<X1, X2, void>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_replace_third<L4, void>, std::tuple<X1, X2, void, X4>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_reverse.cpp b/src/boost/libs/mp11/test/mp_reverse.cpp
new file mode 100644
index 000000000..221440db6
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_reverse.cpp
@@ -0,0 +1,94 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+struct X6 {};
+struct X7 {};
+struct X8 {};
+struct X9 {};
+struct X10 {};
+struct X11 {};
+struct X12 {};
+
+using boost::mp11::mp_plus;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_reverse;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1>>, mp_list<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2>>, mp_list<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3>>, mp_list<X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4>>, mp_list<X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5>>, mp_list<X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6>>, mp_list<X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7>>, mp_list<X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7, X8>>, mp_list<X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7, X8, X9>>, mp_list<X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10>>, mp_list<X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11>>, mp_list<X11, X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<mp_list<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12>>, mp_list<X12, X11, X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1>>, std::tuple<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2>>, std::tuple<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3>>, std::tuple<X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4>>, std::tuple<X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5>>, std::tuple<X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6>>, std::tuple<X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7>>, std::tuple<X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7, X8>>, std::tuple<X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7, X8, X9>>, std::tuple<X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10>>, std::tuple<X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11>>, std::tuple<X11, X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::tuple<X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12>>, std::tuple<X12, X11, X10, X9, X8, X7, X6, X5, X4, X3, X2, X1>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse<std::pair<X1, X2>>, std::pair<X2, X1>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_transform;
+    using boost::mp11::mp_fill;
+
+    {
+        int const N = 37;
+
+        using L = mp_iota_c<N>;
+
+        using R1 = mp_reverse<L>;
+        using R2 = mp_reverse<R1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, L>));
+
+        using R3 = mp_transform<mp_plus, R1, R2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_fill<L, mp_size_t<N-1>>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_reverse_fold.cpp b/src/boost/libs/mp11/test/mp_reverse_fold.cpp
new file mode 100644
index 000000000..75c308993
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_reverse_fold.cpp
@@ -0,0 +1,81 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T1, class T2> struct F {};
+
+using boost::mp11::mp_push_back;
+using boost::mp11::mp_push_front;
+
+template<class T, class L> using rev_push_back = mp_push_back<L, T>;
+template<class T, class L> using rev_push_front = mp_push_front<L, T>;
+
+using boost::mp11::mp_plus;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_reverse_fold;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<mp_list<>, void, F>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<mp_list<X1>, void, F>, F<X1, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<mp_list<X1, X2>, void, F>, F<X1, F<X2, void>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<mp_list<X1, X2, X3>, void, F>, F<X1, F<X2, F<X3, void>>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<mp_list<X1, X2, X3, X4>, void, F>, F<X1, F<X2, F<X3, F<X4, void>>>>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<>, void, F>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1>, void, F>, F<X1, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1, X2>, void, F>, F<X1, F<X2, void>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1, X2, X3>, void, F>, F<X1, F<X2, F<X3, void>>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1, X2, X3, X4>, void, F>, F<X1, F<X2, F<X3, F<X4, void>>>>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1, X2, X3, X4>, mp_list<>, rev_push_back>, mp_list<X4, X3, X2, X1>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold<std::tuple<X1, X2, X3, X4>, mp_list<>, rev_push_front>, mp_list<X1, X2, X3, X4>>));
+    }
+
+    using boost::mp11::mp_iota_c;
+    using boost::mp11::mp_reverse;
+    using boost::mp11::mp_size_t;
+
+    {
+        int const N = 37;
+
+        using L = mp_iota_c<N>;
+
+        using R1 = mp_reverse_fold<L, mp_list<>, rev_push_front>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, L>));
+
+        using R2 = mp_reverse_fold<L, mp_list<>, rev_push_back>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, mp_reverse<L>>));
+
+        using R3 = mp_reverse_fold<L, mp_size_t<0>, mp_plus>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_size_t<N*(N-1)/2>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_reverse_fold_q.cpp b/src/boost/libs/mp11/test/mp_reverse_fold_q.cpp
new file mode 100644
index 000000000..09071a8d1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_reverse_fold_q.cpp
@@ -0,0 +1,66 @@
+
+// Copyright 2015-2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/bind.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T1, class T2> struct F {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_reverse_fold_q;
+    using boost::mp11::mp_quote;
+
+    using Q = mp_quote<F>;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<mp_list<>, void, Q>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<mp_list<X1>, void, Q>, F<X1, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<mp_list<X1, X2>, void, Q>, F<X1, F<X2, void>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<mp_list<X1, X2, X3>, void, Q>, F<X1, F<X2, F<X3, void>>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<mp_list<X1, X2, X3, X4>, void, Q>, F<X1, F<X2, F<X3, F<X4, void>>>>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<>, void, Q>, void>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1>, void, Q>, F<X1, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1, X2>, void, Q>, F<X1, F<X2, void>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1, X2, X3>, void, Q>, F<X1, F<X2, F<X3, void>>>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1, X2, X3, X4>, void, Q>, F<X1, F<X2, F<X3, F<X4, void>>>>>));
+    }
+
+    using boost::mp11::mp_bind;
+    using boost::mp11::_1;
+    using boost::mp11::_2;
+
+    using boost::mp11::mp_push_back;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_bind<mp_push_back, _2, _1>>, mp_list<X4, X3, X2, X1>>));
+    }
+
+    using boost::mp11::mp_push_front;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_reverse_fold_q<std::tuple<X1, X2, X3, X4>, mp_list<>, mp_bind<mp_push_front, _2, _1>>, mp_list<X1, X2, X3, X4>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_rotate_left.cpp b/src/boost/libs/mp11/test/mp_rotate_left.cpp
new file mode 100644
index 000000000..0735eed81
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_rotate_left.cpp
@@ -0,0 +1,136 @@
+
+// Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_rotate_left;
+    using boost::mp11::mp_rotate_left_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 3>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<1>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<3>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<4>>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 0>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 1>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 2>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 3>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 4>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 5>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 6>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 7>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 8>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 9>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 10>, mp_list<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<0>>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<1>>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<2>>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<3>>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<4>>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<5>>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<6>>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<7>>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<8>>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<9>>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<10>>, mp_list<X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 3>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<1>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<3>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<4>>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 0>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 1>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 2>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 3>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 4>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 5>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 6>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 7>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 8>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 9>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L2, 10>, std::tuple<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<0>>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<1>>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<2>>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<3>>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<4>>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<5>>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<6>>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<7>>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<8>>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<9>>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L2, mp_size_t<10>>, std::tuple<X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 1>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 3>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left_c<L1, 5>, std::pair<X2, X1>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<4>>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<1>>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<3>>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_left<L1, mp_size_t<5>>, std::pair<X2, X1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_rotate_right.cpp b/src/boost/libs/mp11/test/mp_rotate_right.cpp
new file mode 100644
index 000000000..14ac5d4cd
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_rotate_right.cpp
@@ -0,0 +1,136 @@
+
+// Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_rotate_right;
+    using boost::mp11::mp_rotate_right_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 3>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<1>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<3>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<4>>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 0>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 1>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 2>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 3>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 4>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 5>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 6>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 7>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 8>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 9>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 10>, mp_list<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<0>>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<1>>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<2>>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<3>>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<4>>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<5>>, mp_list<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<6>>, mp_list<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<7>>, mp_list<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<8>>, mp_list<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<9>>, mp_list<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<10>>, mp_list<X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 1>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 3>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<1>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<3>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<4>>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 0>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 1>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 2>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 3>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 4>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 5>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 6>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 7>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 8>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 9>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L2, 10>, std::tuple<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<0>>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<1>>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<2>>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<3>>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<4>>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<5>>, std::tuple<X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<6>>, std::tuple<X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<7>>, std::tuple<X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<8>>, std::tuple<X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<9>>, std::tuple<X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L2, mp_size_t<10>>, std::tuple<X1, X2, X3, X4, X5>>));
+    }
+
+    {
+        using L1 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 4>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 1>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 3>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right_c<L1, 5>, std::pair<X2, X1>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<0>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<2>>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<4>>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<1>>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<3>>, std::pair<X2, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_rotate_right<L1, mp_size_t<5>>, std::pair<X2, X1>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_same.cpp b/src/boost/libs/mp11/test/mp_same.cpp
new file mode 100644
index 000000000..d23e6b79b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_same.cpp
@@ -0,0 +1,51 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_MSVC
+# pragma warning( disable: 4503 ) // decorated name length exceeded
+#endif
+
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_same;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, void, void, void>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_same<void, void, void, void, int>, mp_false>));
+
+    using boost::mp11::mp_repeat_c;
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_apply;
+
+    int const N = 1024;
+
+    using L = mp_repeat_c<mp_list<void>, N>;
+    using R = mp_apply<mp_same, L>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<R, mp_true>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_second.cpp b/src/boost/libs/mp11/test/mp_second.cpp
new file mode 100644
index 000000000..f585bea49
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_second.cpp
@@ -0,0 +1,34 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_second;
+
+    using L1 = mp_list<void, char[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_second<L1>, char[]>));
+
+    using L2 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_second<L2>, void>));
+
+    using L3 = std::tuple<int, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_second<L3>, float>));
+
+    using L4 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_second<L4>, double>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_contains.cpp b/src/boost/libs/mp11/test/mp_set_contains.cpp
new file mode 100644
index 000000000..d53314613
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_contains.cpp
@@ -0,0 +1,83 @@
+
+//  Copyright 2015 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_contains;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L1, void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L1, int>, mp_false>));
+
+        using L2 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L2, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L2, int>, mp_false>));
+
+        using L3 = mp_list<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, int>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void const>, mp_false>));
+
+        using L4 = mp_list<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, int>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, char[]>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, void const>, mp_false>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L1, void>, mp_false>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L1, int>, mp_false>));
+
+        using L2 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L2, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L2, int>, mp_false>));
+
+        using L3 = std::tuple<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, int>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void const>, mp_false>));
+
+        using L4 = std::tuple<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, int>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, char[]>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L4, void const>, mp_false>));
+    }
+
+    {
+        using L3 = std::pair<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, int>, mp_true>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_contains<L3, void const>, mp_false>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_difference.cpp b/src/boost/libs/mp11/test/mp_set_difference.cpp
new file mode 100644
index 000000000..9e21f4005
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_difference.cpp
@@ -0,0 +1,48 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_difference;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void>>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int>>, mp_list<void, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void>, std::pair<float, int>>, std::tuple<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void, int>, std::pair<float, int>>, std::tuple<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void, int, float>, std::pair<float, int>>, std::tuple<void>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float>, std::tuple<>>, mp_list<void, int, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float>, std::tuple<int>>, mp_list<void, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float>, std::tuple<float, void>>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float>, std::tuple<float, void, int>>, mp_list<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<>, mp_list<>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void>, mp_list<double>, std::pair<float, int>>, std::tuple<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void, int>, mp_list<double, int>, std::pair<float, int>>, std::tuple<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<std::tuple<void, int, float>, mp_list<double, int, float>, std::pair<float, int>>, std::tuple<void>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<>>, mp_list<int, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<int>>, mp_list<float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<float, void>>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_difference<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<float, void, int>>, mp_list<>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_difference_sf.cpp b/src/boost/libs/mp11/test/mp_set_difference_sf.cpp
new file mode 100644
index 000000000..ddcb63d0e
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_difference_sf.cpp
@@ -0,0 +1,33 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    using boost::mp11::mp_set_difference;
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, void, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, void, void, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, mp_list<>, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_difference, mp_list<>, mp_list<>, mp_list<>, mp_list<>, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_intersection.cpp b/src/boost/libs/mp11/test/mp_set_intersection.cpp
new file mode 100644
index 000000000..d9e16dde1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_intersection.cpp
@@ -0,0 +1,49 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_intersection;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void>>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int>>, mp_list<void, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void, int>, std::pair<float, int>>, std::tuple<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void, int, float>, std::pair<float, int>>, std::tuple<int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float>, std::tuple<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float>, std::tuple<int>>, mp_list<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float>, std::tuple<float, void>>, mp_list<void, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float>, std::tuple<float, void, int>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<>, mp_list<>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void>, mp_list<double>, std::pair<float, int>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void, int>, mp_list<double, int>, std::pair<float, int>>, std::tuple<int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<std::tuple<void, int, float>, mp_list<double, int, float>, std::pair<float, int>>, std::tuple<int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<int>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<float, void>>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_intersection<mp_list<void, int, float, double>, std::pair<double, void>, std::tuple<float, void, int>>, mp_list<void>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_intersection_sf.cpp b/src/boost/libs/mp11/test/mp_set_intersection_sf.cpp
new file mode 100644
index 000000000..21af2ef53
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_intersection_sf.cpp
@@ -0,0 +1,32 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    using boost::mp11::mp_set_intersection;
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, void, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, void, void, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, mp_list<>, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_intersection, mp_list<>, mp_list<>, mp_list<>, mp_list<>, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_push_back.cpp b/src/boost/libs/mp11/test/mp_set_push_back.cpp
new file mode 100644
index 000000000..279140e0c
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_push_back.cpp
@@ -0,0 +1,122 @@
+
+// Copyright 2015 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_push_back;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, int>, mp_list<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int, char[]>, mp_list<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int, void, int, void, int>, mp_list<void, int>>));
+    }
+
+    {
+        using L2 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, void>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int, void>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int, int, int, void, void, void>, mp_list<void, int>>));
+    }
+
+    {
+        using L3 = mp_list<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, void>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int, int, int, void, void, void>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, void const>, mp_list<void, int, void const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int, char[], int, char[], void, char[], void, char[]>, mp_list<void, int, char[]>>));
+    }
+
+    {
+        using L4 = mp_list<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, int>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, char[]>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void, int, char[], void, int, char[]>, L4>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void const>, mp_list<void, int, char[], void const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void const, int const, char const[]>, mp_list<void, int, char[], void const, int const, char const[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void, void const, int, int const, char[], char const[]>, mp_list<void, int, char[], void const, int const, char const[]>>));
+    }
+
+    //
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, int>, std::tuple<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int, char[]>, std::tuple<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L1, void, int, void, int, void, int>, std::tuple<void, int>>));
+    }
+
+    {
+        using L2 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, void>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int, void>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L2, int, int, int, void, void, void>, std::tuple<void, int>>));
+    }
+
+    {
+        using L3 = std::tuple<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, void>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int, int, int, void, void, void>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, void const>, std::tuple<void, int, void const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L3, int, char[], int, char[], void, char[], void, char[]>, std::tuple<void, int, char[]>>));
+    }
+
+    {
+        using L4 = std::tuple<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, int>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, char[]>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void, int, char[], void, int, char[]>, L4>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void const>, std::tuple<void, int, char[], void const>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void const, int const, char const[]>, std::tuple<void, int, char[], void const, int const, char const[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_back<L4, void, void const, int, int const, char[], char const[]>, std::tuple<void, int, char[], void const, int const, char const[]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_push_front.cpp b/src/boost/libs/mp11/test/mp_set_push_front.cpp
new file mode 100644
index 000000000..a027ac328
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_push_front.cpp
@@ -0,0 +1,124 @@
+
+//  Copyright 2015 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_push_front;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, int>, mp_list<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int, char[]>, mp_list<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int, void, int, void, int>, mp_list<void, int>>));
+    }
+
+    {
+        using L2 = mp_list<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, int>, mp_list<int, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void, int>, mp_list<int, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void, void, void, int, int, int>, mp_list<int, void>>));
+    }
+
+    {
+        using L3 = mp_list<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int, int, int, void, void, void>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void const>, mp_list<void const, void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void const, int const>, mp_list<void const, int const, void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int, char[], int, char[], void, char[], void, char[]>, mp_list<char[], void, int>>));
+    }
+
+    {
+        using L4 = mp_list<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, int>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, char[]>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void, int, char[], void, int, char[]>, L4>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void const>, mp_list<void const, void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void const, int const, char const[]>, mp_list<void const, int const, char const[], void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void, void const, int, int const, char[], char const[]>, mp_list<void const, int const, char const[], void, int, char[]>>));
+    }
+
+    //
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1>, L1>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, int>, std::tuple<int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int, char[]>, std::tuple<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L1, void, int, void, int, void, int>, std::tuple<void, int>>));
+    }
+
+    {
+        using L2 = std::tuple<void>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2>, L2>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void>, L2>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, int>, std::tuple<int, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void, int>, std::tuple<int, void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L2, void, void, void, int, int, int>, std::tuple<int, void>>));
+    }
+
+    {
+        using L3 = std::tuple<void, int>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int>, L3>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int, int, int, void, void, void>, L3>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void const>, std::tuple<void const, void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, void const, int const>, std::tuple<void const, int const, void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L3, int, char[], int, char[], void, char[], void, char[]>, std::tuple<char[], void, int>>));
+    }
+
+    {
+        using L4 = std::tuple<void, int, char[]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, int>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, char[]>, L4>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void, int, char[], void, int, char[]>, L4>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void const>, std::tuple<void const, void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void const, int const, char const[]>, std::tuple<void const, int const, char const[], void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_push_front<L4, void, void const, int, int const, char[], char const[]>, std::tuple<void const, int const, char const[], void, int, char[]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_union.cpp b/src/boost/libs/mp11/test/mp_set_union.cpp
new file mode 100644
index 000000000..0811d293b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_union.cpp
@@ -0,0 +1,55 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_set_union;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<>, mp_list<>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<>>, mp_list<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void>>, mp_list<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int>>, mp_list<void, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int, float>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<>>, std::tuple<>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void>>, std::tuple<void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int>>, std::tuple<void, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int, float>>, std::tuple<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<>, std::pair<float, int>>, mp_list<float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void>, std::pair<float, int>>, mp_list<void, float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int>, std::pair<float, int>>, mp_list<void, int, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int, float>, std::pair<float, int>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<>, mp_list<>, std::pair<float, int>>, std::tuple<float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void>, mp_list<double>, std::pair<float, int>>, std::tuple<void, double, float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int>, mp_list<double, int>, std::pair<float, int>>, std::tuple<void, int, double, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int, float>, mp_list<double, int, float>, std::pair<float, int>>, std::tuple<void, int, float, double>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<>, std::pair<float, float>, std::pair<int, int>>, mp_list<float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void>, std::pair<float, float>, std::pair<int, int>>, mp_list<void, float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int>, std::pair<float, float>, std::pair<int, int>>, mp_list<void, int, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<mp_list<void, int, float>, std::pair<float, float>, std::pair<int, int>>, mp_list<void, int, float>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<>, std::pair<float, float>, std::pair<int, int>, std::pair<void, void>>, std::tuple<float, int, void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void>, std::pair<float, float>, std::pair<int, int>, std::pair<void, void>>, std::tuple<void, float, int>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int>, std::pair<float, float>, std::pair<int, int>, std::pair<void, void>>, std::tuple<void, int, float>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_set_union<std::tuple<void, int, float>, std::pair<float, float>, std::pair<int, int>, std::pair<void, void>>, std::tuple<void, int, float>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_set_union_sf.cpp b/src/boost/libs/mp11/test/mp_set_union_sf.cpp
new file mode 100644
index 000000000..badf79332
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_set_union_sf.cpp
@@ -0,0 +1,32 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    using boost::mp11::mp_set_union;
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_list;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, void, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, void, void, void, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, mp_list<>, mp_list<>, mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_set_union, mp_list<>, mp_list<>, mp_list<>, mp_list<>, void>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_similar.cpp b/src/boost/libs/mp11/test/mp_similar.cpp
new file mode 100644
index 000000000..140c4edaa
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_similar.cpp
@@ -0,0 +1,50 @@
+
+// Copyright 2019 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/function.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+template<class> class X;
+template<class...> class Y;
+
+int main()
+{
+    using boost::mp11::mp_similar;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, void, void>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, void, void, void>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, void, int>, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<void, void, void, void, int>, mp_false>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<X<void>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<X<void>, X<void>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<X<void>, X<int>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<X<void>, X<void>, X<void>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<X<void>, X<int>, X<float>>, mp_true>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<void>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<>, Y<>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<void>, Y<void, void>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<>, Y<>, Y<>>, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_similar<Y<>, Y<void>, Y<void, void>, Y<void, void, void>>, mp_true>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_size.cpp b/src/boost/libs/mp11/test/mp_size.cpp
new file mode 100644
index 000000000..a8ea75f78
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_size.cpp
@@ -0,0 +1,48 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_size;
+    using boost::mp11::mp_size_t;
+
+    using L1 = mp_list<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L1>, mp_size_t<0>>));
+
+    using L2 = mp_list<void>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L2>, mp_size_t<1>>));
+
+    using L3 = mp_list<int[], void, float>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L3>, mp_size_t<3>>));
+
+    using L4 = std::tuple<>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L4>, mp_size_t<0>>));
+
+    using L5 = std::tuple<int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L5>, mp_size_t<1>>));
+
+    using L6 = std::tuple<int, int>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L6>, mp_size_t<2>>));
+
+    using L7 = std::pair<char, double>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L7>, mp_size_t<2>>));
+
+    using L8 = std::add_const<void()>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_size<L8>, mp_size_t<1>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_sort.cpp b/src/boost/libs/mp11/test/mp_sort.cpp
new file mode 100644
index 000000000..d6b677f48
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_sort.cpp
@@ -0,0 +1,55 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+template<class T, class U> using sizeof_less = mp_bool<(sizeof(T) < sizeof(U))>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_sort;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L1, sizeof_less>, L1>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L2, sizeof_less>, mp_list<char[1], char[2], char[3], char[4]>>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L3, sizeof_less>, mp_list<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L1, sizeof_less>, L1>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L2, sizeof_less>, std::tuple<char[1], char[2], char[3], char[4]>>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort<L3, sizeof_less>, std::tuple<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_sort_q.cpp b/src/boost/libs/mp11/test/mp_sort_q.cpp
new file mode 100644
index 000000000..84f8b455d
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_sort_q.cpp
@@ -0,0 +1,58 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+struct Q_sizeof_less
+{
+    template<class T, class U> using fn = mp_bool<(sizeof(T) < sizeof(U))>;
+};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_sort_q;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L1, Q_sizeof_less>, L1>));
+
+        using L2 = mp_list<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L2, Q_sizeof_less>, mp_list<char[1], char[2], char[3], char[4]>>));
+
+        using L3 = mp_list<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L3, Q_sizeof_less>, mp_list<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L1, Q_sizeof_less>, L1>));
+
+        using L2 = std::tuple<char[2], char[4], char[3], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L2, Q_sizeof_less>, std::tuple<char[1], char[2], char[3], char[4]>>));
+
+        using L3 = std::tuple<char[2], char[4], char[2], char[3], char[1], char[2], char[1]>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_sort_q<L3, Q_sizeof_less>, std::tuple<char[1], char[1], char[2], char[2], char[2], char[3], char[4]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_starts_with.cpp b/src/boost/libs/mp11/test/mp_starts_with.cpp
new file mode 100644
index 000000000..88012201a
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_starts_with.cpp
@@ -0,0 +1,64 @@
+// Copyright 2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+//
+// 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_starts_with;
+    using boost::mp11::mp_true;
+    using boost::mp11::mp_false;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<>,
+        mp_list<> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<>,
+        mp_list<int> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        mp_list<> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<>,
+        std::tuple<int> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<std::tuple<int>,
+        mp_list<> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        mp_list<int> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        mp_list<char> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<std::tuple<int>,
+        mp_list<int> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        std::tuple<char> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void>,
+        mp_list<int> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void>,
+        mp_list<char> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        mp_list<int, void> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<std::pair<int, char>,
+        mp_list<int> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int>,
+        std::pair<int, char> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void>,
+        mp_list<int, void> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void>,
+        mp_list<int, int> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<std::tuple<int, char>,
+        mp_list<int, char> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, char>,
+        std::tuple<int, int> >, mp_false>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void, int>,
+        mp_list<int, void> >, mp_true>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_starts_with<mp_list<int, void, int>,
+        mp_list<int, int> >, mp_false>));
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_starts_with_sf.cpp b/src/boost/libs/mp11/test/mp_starts_with_sf.cpp
new file mode 100644
index 000000000..40d757eb1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_starts_with_sf.cpp
@@ -0,0 +1,45 @@
+// Copyright 2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
+//
+// 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/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+
+int main()
+{
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_starts_with;
+    using boost::mp11::mp_list;
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        mp_list<> >));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        mp_list<int> >));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        mp_list<>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        mp_list<int>, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        void, mp_list<> >));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_starts_with,
+        void, mp_list<int> >));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_starts_with,
+        mp_list<>, mp_list<> >));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_starts_with,
+        mp_list<>, mp_list<int> >));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_starts_with,
+        mp_list<int>, mp_list<> >));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_starts_with,
+        mp_list<int>, mp_list<char> >));
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_take.cpp b/src/boost/libs/mp11/test/mp_take.cpp
new file mode 100644
index 000000000..c7f042272
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_take.cpp
@@ -0,0 +1,106 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+struct X5 {};
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_take;
+    using boost::mp11::mp_take_c;
+    using boost::mp11::mp_size_t;
+
+    {
+        using L1 = mp_list<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L1, mp_size_t<0>>, L1>));
+
+        using L2 = mp_list<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 0>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 1>, mp_list<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 2>, mp_list<X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 3>, mp_list<X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 4>, mp_list<X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 5>, mp_list<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<0>>, mp_list<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<1>>, mp_list<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<2>>, mp_list<X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<3>>, mp_list<X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<4>>, mp_list<X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<5>>, mp_list<X1, X2, X3, X4, X5>>));
+
+        using L3 = mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3,  6>, mp_list<X1, X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3,  7>, mp_list<X1, X2, X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3,  8>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3,  9>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3, 10>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3, 11>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t< 6>>, mp_list<X1, X2, X3, X4, X5, X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t< 7>>, mp_list<X1, X2, X3, X4, X5, X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t< 8>>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t< 9>>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t<10>>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t<11>>, mp_list<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1>>));
+    }
+
+    {
+        using L1 = std::tuple<>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L1, 0>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L1, mp_size_t<0>>, L1>));
+
+        using L2 = std::tuple<X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 0>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 1>, std::tuple<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 2>, std::tuple<X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 3>, std::tuple<X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 4>, std::tuple<X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L2, 5>, std::tuple<X1, X2, X3, X4, X5>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<0>>, std::tuple<>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<1>>, std::tuple<X1>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<2>>, std::tuple<X1, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<3>>, std::tuple<X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<4>>, std::tuple<X1, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L2, mp_size_t<5>>, std::tuple<X1, X2, X3, X4, X5>>));
+
+        using L3 = std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5, X1, X2, X3, X4, X5>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L3, 8>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L3, mp_size_t<9>>, std::tuple<X1, X2, X3, X4, X5, X1, X2, X3, X4>>));
+    }
+
+    {
+        using L1 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take_c<L1, 2>, L1>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_take<L1, mp_size_t<2>>, L1>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_third.cpp b/src/boost/libs/mp11/test/mp_third.cpp
new file mode 100644
index 000000000..c43b85da7
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_third.cpp
@@ -0,0 +1,28 @@
+
+//  Copyright 2015 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/core/lightweight_test_trait.hpp>
+#include <boost/mp11/list.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_third;
+
+    using L1 = mp_list<int[], void, float[]>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_third<L1>, float[]>));
+
+    using L2 = std::tuple<int, float, char>;
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_third<L2>, char>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform.cpp b/src/boost/libs/mp11/test/mp_transform.cpp
new file mode 100644
index 000000000..ed6f1ddec
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform.cpp
@@ -0,0 +1,105 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+struct Y1 {};
+struct Y2 {};
+struct Y3 {};
+struct Y4 {};
+
+struct Z1 {};
+struct Z2 {};
+struct Z3 {};
+struct Z4 {};
+
+struct U1 {};
+struct U2 {};
+
+struct V1 {};
+struct V2 {};
+
+struct W1 {};
+struct W2 {};
+
+template<class T> using add_pointer = typename std::add_pointer<T>::type;
+template<class T, class U> using is_same = typename std::is_same<T, U>::type;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform;
+
+    using L1 = mp_list<X1, X2, X3, X4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L1>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L1>, mp_list<std::tuple<X1>, std::tuple<X2>, std::tuple<X3>, std::tuple<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::add_pointer, L1>, mp_list<std::add_pointer<X1>, std::add_pointer<X2>, std::add_pointer<X3>, std::add_pointer<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<add_pointer, L1>, mp_list<X1*, X2*, X3*, X4*>>));
+
+    using L2 = std::tuple<Y1, Y2, Y3, Y4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L1, L2>, mp_list<mp_list<X1, Y1>, mp_list<X2, Y2>, mp_list<X3, Y3>, mp_list<X4, Y4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L1, L2>, mp_list<std::tuple<X1, Y1>, std::tuple<X2, Y2>, std::tuple<X3, Y3>, std::tuple<X4, Y4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::pair, L1, L2>, mp_list<std::pair<X1, Y1>, std::pair<X2, Y2>, std::pair<X3, Y3>, std::pair<X4, Y4>>>));
+
+    using L3 = mp_list<Z1, Z2, Z3, Z4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L1, L2, L3>, mp_list<mp_list<X1, Y1, Z1>, mp_list<X2, Y2, Z2>, mp_list<X3, Y3, Z3>, mp_list<X4, Y4, Z4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L1, L2, L3>, mp_list<std::tuple<X1, Y1, Z1>, std::tuple<X2, Y2, Z2>, std::tuple<X3, Y3, Z3>, std::tuple<X4, Y4, Z4>>>));
+
+    //
+
+    using L4 = std::tuple<X1, Y2, X3, Y4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L1, L1>, mp_list<std::true_type, std::true_type, std::true_type, std::true_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L1, L2>, mp_list<std::false_type, std::false_type, std::false_type, std::false_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L1, L4>, mp_list<std::true_type, std::false_type, std::true_type, std::false_type>>));
+
+    //
+
+    using L5 = std::pair<X1, X2>;
+    using L6 = std::pair<Y1, Y2>;
+    using L7 = std::pair<X1, Y2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L5>, std::pair<mp_list<X1>, mp_list<X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L5, L6>, std::pair<mp_list<X1, Y1>, mp_list<X2, Y2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<mp_list, L5, L6, L7>, std::pair<mp_list<X1, Y1, X1>, mp_list<X2, Y2, Y2>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<add_pointer, L5>, std::pair<X1*, X2*>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L5, L5>, std::pair<std::true_type, std::true_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L5, L6>, std::pair<std::false_type, std::false_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<is_same, L5, L7>, std::pair<std::true_type, std::false_type>>));
+
+    //
+
+    using L8 = std::pair<Z1, Z2>;
+    using L9 = std::pair<U1, U2>;
+    using L10 = std::pair<V1, V2>;
+    using L11 = std::pair<W1, W2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L5, L6, L8, L9>, std::pair<std::tuple<X1, Y1, Z1, U1>, std::tuple<X2, Y2, Z2, U2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L5, L6, L8, L9, L10>, std::pair<std::tuple<X1, Y1, Z1, U1, V1>, std::tuple<X2, Y2, Z2, U2, V2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform<std::tuple, L5, L6, L8, L9, L10, L11>, std::pair<std::tuple<X1, Y1, Z1, U1, V1, W1>, std::tuple<X2, Y2, Z2, U2, V2, W2>>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_front.cpp b/src/boost/libs/mp11/test/mp_transform_front.cpp
new file mode 100644
index 000000000..8711128f6
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_front.cpp
@@ -0,0 +1,112 @@
+
+// Copyright 2015, 2017, 2019 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/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T> using add_pointer_t = T*;
+using Q_add_pointer = boost::mp11::mp_quote_trait<std::add_pointer>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform_front;
+    using boost::mp11::mp_transform_first;
+    using boost::mp11::mp_transform_front_q;
+    using boost::mp11::mp_transform_first_q;
+
+    {
+        using L1 = mp_list<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L1, add_pointer_t>, mp_list<X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L1, add_pointer_t>, mp_list<X1*>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L1, Q_add_pointer>, mp_list<X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L1, Q_add_pointer>, mp_list<X1*>>));
+
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L2, add_pointer_t>, mp_list<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L2, add_pointer_t>, mp_list<X1*, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L2, Q_add_pointer>, mp_list<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L2, Q_add_pointer>, mp_list<X1*, X2>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L3, add_pointer_t>, mp_list<X1*, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L3, add_pointer_t>, mp_list<X1*, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L3, Q_add_pointer>, mp_list<X1*, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L3, Q_add_pointer>, mp_list<X1*, X2, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L4, add_pointer_t>, mp_list<X1*, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L4, add_pointer_t>, mp_list<X1*, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L4, Q_add_pointer>, mp_list<X1*, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L4, Q_add_pointer>, mp_list<X1*, X2, X3, X4>>));
+    }
+
+    {
+        using L1 = std::tuple<X1>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L1, add_pointer_t>, std::tuple<X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L1, add_pointer_t>, std::tuple<X1*>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L1, Q_add_pointer>, std::tuple<X1*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L1, Q_add_pointer>, std::tuple<X1*>>));
+
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L2, add_pointer_t>, std::tuple<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L2, add_pointer_t>, std::tuple<X1*, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L2, Q_add_pointer>, std::tuple<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L2, Q_add_pointer>, std::tuple<X1*, X2>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L3, add_pointer_t>, std::tuple<X1*, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L3, add_pointer_t>, std::tuple<X1*, X2, X3>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L3, Q_add_pointer>, std::tuple<X1*, X2, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L3, Q_add_pointer>, std::tuple<X1*, X2, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L4, add_pointer_t>, std::tuple<X1*, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L4, add_pointer_t>, std::tuple<X1*, X2, X3, X4>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L4, Q_add_pointer>, std::tuple<X1*, X2, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L4, Q_add_pointer>, std::tuple<X1*, X2, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front<L2, add_pointer_t>, std::pair<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first<L2, add_pointer_t>, std::pair<X1*, X2>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_front_q<L2, Q_add_pointer>, std::pair<X1*, X2>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_first_q<L2, Q_add_pointer>, std::pair<X1*, X2>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_if.cpp b/src/boost/libs/mp11/test/mp_transform_if.cpp
new file mode 100644
index 000000000..048909aaf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_if.cpp
@@ -0,0 +1,74 @@
+
+//  Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+using boost::mp11::mp_not;
+
+template<class T> using add_pointer = T*;
+template<class T, class...> using is_not_ref = mp_not<std::is_reference<T>>;
+template<class T1, class T2> using second = T2;
+template<class T1, class T2, class T3> using third = T3;
+template<class T1, class T2, class T3, class T4> using fourth = T4;
+template<class T1, class T2, class T3, class T4, class T5> using fifth = T5;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform_if;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_size;
+    using boost::mp11::mp_fill;
+    using boost::mp11::mp_iota;
+
+    using L1 = mp_list<X1, X2&, X3 const, X4 const&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, add_pointer, L1>, mp_list<X1*, X2&, X3 const*, X4 const&>>));
+
+    using L2 = std::tuple<X1, X2&, X3 const, X4 const&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, add_pointer, L2>, std::tuple<X1*, X2&, X3 const*, X4 const&>>));
+
+    using L3 = std::pair<X1 const, X2&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, add_pointer, L3>, std::pair<X1 const*, X2&>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L1, mp_fill<L1, void>>, mp_list<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L2, mp_fill<L2, void>>, std::tuple<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, second, L3, mp_fill<L3, void>>, std::pair<void, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, third, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fourth, L1, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fourth, L2, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fourth, L3, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fifth, L1, L1, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fifth, L2, L2, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if<is_not_ref, fifth, L3, L3, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_if_q.cpp b/src/boost/libs/mp11/test/mp_transform_if_q.cpp
new file mode 100644
index 000000000..b2087be82
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_if_q.cpp
@@ -0,0 +1,87 @@
+
+// Copyright 2015, 2017 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+using boost::mp11::mp_not;
+using boost::mp11::mp_quote;
+
+template<class T> using add_pointer = T*;
+using Q_add_pointer = mp_quote<add_pointer>;
+
+template<class T, class...> using is_not_ref = mp_not<std::is_reference<T>>;
+using Q_is_not_ref = mp_quote<is_not_ref>;
+
+template<class T1, class T2> using second = T2;
+using Q_second = mp_quote<second>;
+
+template<class T1, class T2, class T3> using third = T3;
+using Q_third = mp_quote<third>;
+
+template<class T1, class T2, class T3, class T4> using fourth = T4;
+using Q_fourth = mp_quote<fourth>;
+
+template<class T1, class T2, class T3, class T4, class T5> using fifth = T5;
+using Q_fifth = mp_quote<fifth>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform_if_q;
+    using boost::mp11::mp_size_t;
+    using boost::mp11::mp_size;
+    using boost::mp11::mp_fill;
+    using boost::mp11::mp_iota;
+
+    using L1 = mp_list<X1, X2&, X3 const, X4 const&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_add_pointer, L1>, mp_list<X1*, X2&, X3 const*, X4 const&>>));
+
+    using L2 = std::tuple<X1, X2&, X3 const, X4 const&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_add_pointer, L2>, std::tuple<X1*, X2&, X3 const*, X4 const&>>));
+
+    using L3 = std::pair<X1 const, X2&>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_add_pointer, L3>, std::pair<X1 const*, X2&>>));
+
+    //
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_second, L1, mp_fill<L1, void>>, mp_list<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_second, L2, mp_fill<L2, void>>, std::tuple<void, X2&, void, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_second, L3, mp_fill<L3, void>>, std::pair<void, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_third, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_third, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_third, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fourth, L1, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fourth, L2, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fourth, L3, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fifth, L1, L1, L1, L1, mp_iota<mp_size<L1>>>, mp_list<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fifth, L2, L2, L2, L2, mp_iota<mp_size<L2>>>, std::tuple<mp_size_t<0>, X2&, mp_size_t<2>, X4 const&>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_if_q<Q_is_not_ref, Q_fifth, L3, L3, L3, L3, mp_iota<mp_size<L3>>>, std::pair<mp_size_t<0>, X2&>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_q.cpp b/src/boost/libs/mp11/test/mp_transform_q.cpp
new file mode 100644
index 000000000..6c73cb1d3
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_q.cpp
@@ -0,0 +1,114 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+struct Y1 {};
+struct Y2 {};
+struct Y3 {};
+struct Y4 {};
+
+struct Z1 {};
+struct Z2 {};
+struct Z3 {};
+struct Z4 {};
+
+struct U1 {};
+struct U2 {};
+
+struct V1 {};
+struct V2 {};
+
+struct W1 {};
+struct W2 {};
+
+using boost::mp11::mp_quote;
+using boost::mp11::mp_list;
+
+template<class T> using add_pointer = typename std::add_pointer<T>::type;
+using Q_add_pointer = mp_quote<add_pointer>;
+
+template<class T, class U> using is_same = typename std::is_same<T, U>::type;
+using Q_is_same = mp_quote<is_same>;
+
+using Q_mp_list = mp_quote<mp_list>;
+using Q_std_tuple = mp_quote<std::tuple>;
+using Q_std_pair = mp_quote<std::pair>;
+
+int main()
+{
+    using boost::mp11::mp_transform_q;
+
+    using L1 = mp_list<X1, X2, X3, X4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L1>, mp_list<mp_list<X1>, mp_list<X2>, mp_list<X3>, mp_list<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L1>, mp_list<std::tuple<X1>, std::tuple<X2>, std::tuple<X3>, std::tuple<X4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_add_pointer, L1>, mp_list<X1*, X2*, X3*, X4*>>));
+
+    using L2 = std::tuple<Y1, Y2, Y3, Y4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L1, L2>, mp_list<mp_list<X1, Y1>, mp_list<X2, Y2>, mp_list<X3, Y3>, mp_list<X4, Y4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L1, L2>, mp_list<std::tuple<X1, Y1>, std::tuple<X2, Y2>, std::tuple<X3, Y3>, std::tuple<X4, Y4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_pair, L1, L2>, mp_list<std::pair<X1, Y1>, std::pair<X2, Y2>, std::pair<X3, Y3>, std::pair<X4, Y4>>>));
+
+    using L3 = mp_list<Z1, Z2, Z3, Z4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L1, L2, L3>, mp_list<mp_list<X1, Y1, Z1>, mp_list<X2, Y2, Z2>, mp_list<X3, Y3, Z3>, mp_list<X4, Y4, Z4>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L1, L2, L3>, mp_list<std::tuple<X1, Y1, Z1>, std::tuple<X2, Y2, Z2>, std::tuple<X3, Y3, Z3>, std::tuple<X4, Y4, Z4>>>));
+
+    //
+
+    using L4 = std::tuple<X1, Y2, X3, Y4>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L1, L1>, mp_list<std::true_type, std::true_type, std::true_type, std::true_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L1, L2>, mp_list<std::false_type, std::false_type, std::false_type, std::false_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L1, L4>, mp_list<std::true_type, std::false_type, std::true_type, std::false_type>>));
+
+    //
+
+    using L5 = std::pair<X1, X2>;
+    using L6 = std::pair<Y1, Y2>;
+    using L7 = std::pair<X1, Y2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L5>, std::pair<mp_list<X1>, mp_list<X2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L5, L6>, std::pair<mp_list<X1, Y1>, mp_list<X2, Y2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_mp_list, L5, L6, L7>, std::pair<mp_list<X1, Y1, X1>, mp_list<X2, Y2, Y2>>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_add_pointer, L5>, std::pair<X1*, X2*>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L5, L5>, std::pair<std::true_type, std::true_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L5, L6>, std::pair<std::false_type, std::false_type>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_is_same, L5, L7>, std::pair<std::true_type, std::false_type>>));
+
+    //
+
+    using L8 = std::pair<Z1, Z2>;
+    using L9 = std::pair<U1, U2>;
+    using L10 = std::pair<V1, V2>;
+    using L11 = std::pair<W1, W2>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L5, L6, L8, L9>, std::pair<std::tuple<X1, Y1, Z1, U1>, std::tuple<X2, Y2, Z2, U2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L5, L6, L8, L9, L10>, std::pair<std::tuple<X1, Y1, Z1, U1, V1>, std::tuple<X2, Y2, Z2, U2, V2>>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_q<Q_std_tuple, L5, L6, L8, L9, L10, L11>, std::pair<std::tuple<X1, Y1, Z1, U1, V1, W1>, std::tuple<X2, Y2, Z2, U2, V2, W2>>>));
+
+    //
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_second.cpp b/src/boost/libs/mp11/test/mp_transform_second.cpp
new file mode 100644
index 000000000..f51dcbb55
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_second.cpp
@@ -0,0 +1,73 @@
+
+// Copyright 2015, 2017, 2019 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/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T> using add_pointer_t = T*;
+using Q_add_pointer = boost::mp11::mp_quote_trait<std::add_pointer>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform_second;
+    using boost::mp11::mp_transform_second_q;
+
+    {
+        using L2 = mp_list<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L2, add_pointer_t>, mp_list<X1, X2*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L2, Q_add_pointer>, mp_list<X1, X2*>>));
+
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L3, add_pointer_t>, mp_list<X1, X2*, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L3, Q_add_pointer>, mp_list<X1, X2*, X3>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L4, add_pointer_t>, mp_list<X1, X2*, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L4, Q_add_pointer>, mp_list<X1, X2*, X3, X4>>));
+    }
+
+    {
+        using L2 = std::tuple<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L2, add_pointer_t>, std::tuple<X1, X2*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L2, Q_add_pointer>, std::tuple<X1, X2*>>));
+
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L3, add_pointer_t>, std::tuple<X1, X2*, X3>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L3, Q_add_pointer>, std::tuple<X1, X2*, X3>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L4, add_pointer_t>, std::tuple<X1, X2*, X3, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L4, Q_add_pointer>, std::tuple<X1, X2*, X3, X4>>));
+    }
+
+    {
+        using L2 = std::pair<X1, X2>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second<L2, add_pointer_t>, std::pair<X1, X2*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_second_q<L2, Q_add_pointer>, std::pair<X1, X2*>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_sf.cpp b/src/boost/libs/mp11/test/mp_transform_sf.cpp
new file mode 100644
index 000000000..e4f5515d2
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_sf.cpp
@@ -0,0 +1,43 @@
+
+//  Copyright 2017 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/algorithm.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using boost::mp11::mp_transform;
+using boost::mp11::mp_list;
+using boost::mp11::mp_valid;
+
+template<class...> using F = void;
+
+template<class... L> using transform = mp_transform<F, L...>;
+
+int main()
+{
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, void, void, void, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, void, void, void, void, void>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    BOOST_TEST_TRAIT_TRUE((mp_valid<transform, mp_list<>>));
+#endif
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, mp_list<>, mp_list<void>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, mp_list<>, mp_list<>, mp_list<void>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, mp_list<>, mp_list<>, mp_list<>, mp_list<void>>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<transform, mp_list<>, mp_list<>, mp_list<>, mp_list<>, mp_list<void>>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_transform_third.cpp b/src/boost/libs/mp11/test/mp_transform_third.cpp
new file mode 100644
index 000000000..7f5376732
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_transform_third.cpp
@@ -0,0 +1,56 @@
+
+// Copyright 2015, 2017, 2019 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/list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <utility>
+
+struct X1 {};
+struct X2 {};
+struct X3 {};
+struct X4 {};
+
+template<class T> using add_pointer_t = T*;
+using Q_add_pointer = boost::mp11::mp_quote_trait<std::add_pointer>;
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_transform_third;
+    using boost::mp11::mp_transform_third_q;
+
+    {
+        using L3 = mp_list<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third<L3, add_pointer_t>, mp_list<X1, X2, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third_q<L3, Q_add_pointer>, mp_list<X1, X2, X3*>>));
+
+        using L4 = mp_list<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third<L4, add_pointer_t>, mp_list<X1, X2, X3*, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third_q<L4, Q_add_pointer>, mp_list<X1, X2, X3*, X4>>));
+    }
+
+    {
+        using L3 = std::tuple<X1, X2, X3>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third<L3, add_pointer_t>, std::tuple<X1, X2, X3*>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third_q<L3, Q_add_pointer>, std::tuple<X1, X2, X3*>>));
+
+        using L4 = std::tuple<X1, X2, X3, X4>;
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third<L4, add_pointer_t>, std::tuple<X1, X2, X3*, X4>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_transform_third_q<L4, Q_add_pointer>, std::tuple<X1, X2, X3*, X4>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_unique.cpp b/src/boost/libs/mp11/test/mp_unique.cpp
new file mode 100644
index 000000000..697d4ce29
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_unique.cpp
@@ -0,0 +1,54 @@
+
+//  Copyright 2015 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/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_unique;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<>>, mp_list<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void>>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, void>>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, void, void>>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, void, void, void>>, mp_list<void>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, int>>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, void, void, int, int, int>>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, int, void, int, int, void, int, int, int>>, mp_list<void, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, int, char[]>>, mp_list<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<mp_list<void, int, char[], void, int, char[], void, int, char[]>>, mp_list<void, int, char[]>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<>>, std::tuple<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void>>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, void>>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, void, void>>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, void, void, void>>, std::tuple<void>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, int>>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, void, void, int, int, int>>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, int, void, int, int, void, int, int, int>>, std::tuple<void, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, int, char[]>>, std::tuple<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique<std::tuple<void, int, char[], void, int, char[], void, int, char[]>>, std::tuple<void, int, char[]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_unique_if.cpp b/src/boost/libs/mp11/test/mp_unique_if.cpp
new file mode 100644
index 000000000..3e579a6b8
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_unique_if.cpp
@@ -0,0 +1,110 @@
+// Copyright 2015 Peter Dimov.
+// Copyright 2019 Kris Jusiak.
+//
+// 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/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+#include <cstddef>
+
+using boost::mp11::mp_bool;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MSVC, < 1910 )
+
+template<class T, class U> using Eq1 = mp_bool< T::value == U::value >;
+template<class T, class U> using Eq2 = mp_bool< sizeof(T) == sizeof(U) >;
+
+#else
+
+template<class T, class U> struct Eq1: mp_bool< T::value == U::value > {};
+template<class T, class U> struct Eq2: mp_bool< sizeof(T) == sizeof(U) > {};
+
+#endif
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_unique_if;
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<>, std::is_same>, mp_list<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void>, std::is_same>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, void>, std::is_same>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, void, void>, std::is_same>, mp_list<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, void, void, void>, std::is_same>, mp_list<void>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, int>, std::is_same>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, void, void, int, int, int>, std::is_same>, mp_list<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, int, void, int, int, void, int, int, int>, std::is_same>, mp_list<void, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, int, char[]>, std::is_same>, mp_list<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<mp_list<void, int, char[], void, int, char[], void, int, char[]>, std::is_same>, mp_list<void, int, char[]>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<>, std::is_same>, std::tuple<>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void>, std::is_same>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, void>, std::is_same>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, void, void>, std::is_same>, std::tuple<void>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, void, void, void>, std::is_same>, std::tuple<void>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, int>, std::is_same>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, void, void, int, int, int>, std::is_same>, std::tuple<void, int>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, int, void, int, int, void, int, int, int>, std::is_same>, std::tuple<void, int>>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, int, char[]>, std::is_same>, std::tuple<void, int, char[]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<void, int, char[], void, int, char[], void, int, char[]>, std::is_same>, std::tuple<void, int, char[]>>));
+    }
+
+    {
+        using boost::mp11::mp_iota_c;
+        using boost::mp11::mp_size_t;
+
+        using L1 = mp_iota_c<32>;
+
+        using R1 = mp_unique_if<L1, std::is_same>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, L1>));
+
+        using R2 = mp_unique_if<L1, Eq1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, L1>));
+
+        using R3 = mp_unique_if<L1, Eq2>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_list<mp_size_t<0>>>));
+    }
+
+    {
+        using boost::mp11::mp_list_c;
+        using boost::mp11::mp_append;
+        using boost::mp11::mp_push_back;
+        using boost::mp11::mp_int;
+
+        using L1 = mp_list_c<std::size_t, 0, 1, 2, 3>;
+        using L2 = mp_list_c<int, 1, 2, 3, 4>;
+        using L3 = mp_list_c<long, 2, 3, 4, 5>;
+
+        using R1 = mp_unique_if<mp_append<L1, L2, L3>, Eq1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_push_back<L1, mp_int<4>, std::integral_constant<long, 5>>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<char[1], char[2], char[1], char[2], char[2], char[1], char[2], char[2], char[2]>, Eq2>, std::tuple<char[1], char[2]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if<std::tuple<char[1], char[2], char[3], char[1], char[2], char[3], char[1], char[2], char[3]>, Eq2>, std::tuple<char[1], char[2], char[3]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_unique_if_q.cpp b/src/boost/libs/mp11/test/mp_unique_if_q.cpp
new file mode 100644
index 000000000..10fc47961
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_unique_if_q.cpp
@@ -0,0 +1,93 @@
+// Copyright 2015 Peter Dimov.
+// Copyright 2019 Kris Jusiak.
+//
+// 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/config.hpp>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+using boost::mp11::mp_bool;
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MSVC, < 1910 )
+
+struct Q1
+{
+    template<class T, class U> using fn = mp_bool< T::value == U::value >;
+};
+
+struct Q2
+{
+    template<class T, class U> using fn = mp_bool< sizeof(T) == sizeof(U) >;
+};
+
+#else
+
+struct Q1
+{
+    template<class T, class U> struct fn: mp_bool< T::value == U::value > {};
+};
+
+struct Q2
+{
+    template<class T, class U> struct fn: mp_bool< sizeof(T) == sizeof(U) > {};
+};
+
+#endif
+
+int main()
+{
+    using boost::mp11::mp_list;
+    using boost::mp11::mp_unique_if_q;
+    using boost::mp11::mp_quote_trait;
+
+    {
+        using boost::mp11::mp_iota_c;
+        using boost::mp11::mp_size_t;
+
+        using L1 = mp_iota_c<32>;
+
+        using R1 = mp_unique_if_q<L1, mp_quote_trait<std::is_same>>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, L1>));
+
+        using R2 = mp_unique_if_q<L1, Q1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R2, L1>));
+
+        using R3 = mp_unique_if_q<L1, Q2>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R3, mp_list<mp_size_t<0>>>));
+    }
+
+    {
+        using boost::mp11::mp_list_c;
+        using boost::mp11::mp_append;
+        using boost::mp11::mp_push_back;
+        using boost::mp11::mp_int;
+
+        using L1 = mp_list_c<std::size_t, 0, 1, 2, 3>;
+        using L2 = mp_list_c<int, 1, 2, 3, 4>;
+        using L3 = mp_list_c<long, 2, 3, 4, 5>;
+
+        using R1 = mp_unique_if_q<mp_append<L1, L2, L3>, Q1>;
+        BOOST_TEST_TRAIT_TRUE((std::is_same<R1, mp_push_back<L1, mp_int<4>, std::integral_constant<long, 5>>>));
+    }
+
+    {
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if_q<std::tuple<char[1], char[2], char[1], char[2], char[2], char[1], char[2], char[2], char[2]>, Q2>, std::tuple<char[1], char[2]>>));
+        BOOST_TEST_TRAIT_TRUE((std::is_same<mp_unique_if_q<std::tuple<char[1], char[2], char[3], char[1], char[2], char[3], char[1], char[2], char[3]>, Q2>, std::tuple<char[1], char[2], char[3]>>));
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_valid.cpp b/src/boost/libs/mp11/test/mp_valid.cpp
new file mode 100644
index 000000000..9a95b944b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_valid.cpp
@@ -0,0 +1,99 @@
+
+// Copyright 2015 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/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T> struct Xi
+{
+};
+
+template<> struct Xi<void>
+{
+    using type = void;
+};
+
+template<class T> using X = typename Xi<T>::type;
+
+template<class T> using add_pointer = T*;
+template<class T> using add_reference = T&;
+template<class T> using add_extents = T[];
+
+using boost::mp11::mp_quote;
+
+using QX = mp_quote<X>;
+using Q_add_pointer = mp_quote<add_pointer>;
+
+int main()
+{
+    using boost::mp11::mp_valid;
+    using boost::mp11::mp_valid_q;
+    using boost::mp11::mp_identity;
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_identity>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<mp_identity, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<mp_identity, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<X>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<X, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<X, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<X, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<QX::fn>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<QX::fn, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<QX::fn, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<QX::fn, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid_q<QX>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid_q<QX, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid_q<QX, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid_q<QX, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_pointer>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<add_pointer, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<add_pointer, int>));
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    // msvc-12.0 can form pointer to reference
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_pointer, int&>));
+#endif
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_pointer, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<Q_add_pointer::fn>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<Q_add_pointer::fn, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<Q_add_pointer::fn, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<Q_add_pointer::fn, void, void>));
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid_q<Q_add_pointer>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid_q<Q_add_pointer, void>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid_q<Q_add_pointer, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid_q<Q_add_pointer, void, void>));
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 70000 )
+    // g++ up to at least 6.3 doesn't like add_reference for some reason or other
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_reference>));
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    // msvc-12.0 gives an internal error here
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_reference, void>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((mp_valid<add_reference, int>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_reference, int, int>));
+#endif
+
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_extents>));
+    BOOST_TEST_TRAIT_TRUE((mp_valid<add_extents, int>));
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    // msvc-12.0 can form arrays to void or int&
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_extents, void>));
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_extents, int&>));
+#endif
+    BOOST_TEST_TRAIT_FALSE((mp_valid<add_extents, int, int>));
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_with_index.cpp b/src/boost/libs/mp11/test/mp_with_index.cpp
new file mode 100644
index 000000000..85a142d16
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_with_index.cpp
@@ -0,0 +1,95 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if BOOST_MP11_MSVC
+# pragma warning( disable: 4503 ) // decorated name length exceeded
+#endif
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <tuple>
+
+using boost::mp11::mp_size_t;
+using boost::mp11::mp_for_each;
+using boost::mp11::mp_with_index;
+using boost::mp11::mp_iota_c;
+
+struct F
+{
+    std::size_t i_;
+
+    explicit F( std::size_t i ): i_( i ) {}
+
+    template<std::size_t I> bool operator()( mp_size_t<I> ) const
+    {
+        BOOST_TEST_EQ( I, i_ );
+        return false;
+    }
+};
+
+struct G
+{
+    void operator()( mp_size_t<0> ) const
+    {
+    }
+
+    template<std::size_t N> void operator()( mp_size_t<N> ) const
+    {
+        for( std::size_t i = 0; i < N; ++i )
+        {
+            mp_with_index<N>( i, F(i) );
+            mp_with_index<mp_size_t<N>>( i, F(i) );
+        }
+    }
+};
+
+int main()
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+    G()( mp_size_t<1>{} );
+    G()( mp_size_t<2>{} );
+    G()( mp_size_t<3>{} );
+    G()( mp_size_t<4>{} );
+    G()( mp_size_t<5>{} );
+    G()( mp_size_t<6>{} );
+    G()( mp_size_t<7>{} );
+    G()( mp_size_t<8>{} );
+    G()( mp_size_t<9>{} );
+    G()( mp_size_t<10>{} );
+    G()( mp_size_t<11>{} );
+    G()( mp_size_t<12>{} );
+    G()( mp_size_t<13>{} );
+    G()( mp_size_t<14>{} );
+    G()( mp_size_t<15>{} );
+    G()( mp_size_t<16>{} );
+
+    G()( mp_size_t<32+1>{} );
+
+    G()( mp_size_t<48+2>{} );
+
+    G()( mp_size_t<64+3>{} );
+
+    G()( mp_size_t<96+4>{} );
+
+    G()( mp_size_t<112+5>{} );
+
+    G()( mp_size_t<128+6>{} );
+
+#else
+
+    mp_for_each<mp_iota_c<134>>( G() );
+
+#endif
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mp_with_index_cx.cpp b/src/boost/libs/mp11/test/mp_with_index_cx.cpp
new file mode 100644
index 000000000..3be9c2cfe
--- /dev/null
+++ b/src/boost/libs/mp11/test/mp_with_index_cx.cpp
@@ -0,0 +1,39 @@
+
+// Copyright 2017 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/config.hpp>
+
+#if !defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+int main() {}
+
+#else
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using boost::mp11::mp_size_t;
+using boost::mp11::mp_with_index;
+
+struct F
+{
+    template<std::size_t I> constexpr std::size_t operator()( mp_size_t<I> ) const
+    {
+        return I;
+    }
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+int main()
+{
+    constexpr std::size_t i = mp_with_index<64>( 57, F{} );
+    STATIC_ASSERT( i == 57 );
+}
+
+#endif
diff --git a/src/boost/libs/mp11/test/mpl.cpp b/src/boost/libs/mp11/test/mpl.cpp
new file mode 100644
index 000000000..5e9551eca
--- /dev/null
+++ b/src/boost/libs/mp11/test/mpl.cpp
@@ -0,0 +1,108 @@
+
+// Copyright 2017 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/mpl.hpp>
+#include <boost/mp11/list.hpp>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/back.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/distance.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/erase.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/reverse.hpp>
+#include <boost/mpl/remove.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/back_inserter.hpp>
+
+#include <boost/core/lightweight_test_trait.hpp>
+#include <type_traits>
+#include <tuple>
+
+template<class T> using add_pointer_t = typename std::add_pointer<T>::type;
+
+template<class L1> void test()
+{
+    namespace mpl = boost::mpl;
+    using namespace boost::mp11;
+
+    // intrinsics
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<0>>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<1>>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<2>>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 0>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 1>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 2>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::back<L1>::type, float>));
+
+    BOOST_TEST_EQ((mpl::distance<typename mpl::begin<L1>::type, typename mpl::end<L1>::type>::type::value), mp_size<L1>::value);
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::clear<L1>::type, mp_clear<L1>>));
+
+    BOOST_TEST_TRAIT_FALSE((typename mpl::empty<L1>::type));
+    BOOST_TEST_TRAIT_TRUE((typename mpl::empty<mp_clear<L1>>::type));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::erase<L1, typename mpl::begin<L1>::type>::type, mp_pop_front<L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::front<L1>::type, mp_front<L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::insert<L1, typename mpl::begin<L1>::type, void>::type, mp_push_front<L1, void>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::insert<L1, typename mpl::end<L1>::type, void>::type, mp_push_back<L1, void>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::insert_range<L1, typename mpl::end<L1>::type, L1>::type, mp_append<L1, L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((typename mpl::is_sequence<L1>::type));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::pop_front<L1>::type, mp_pop_front<L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::push_back<L1, char>::type, mp_push_back<L1, char>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::push_front<L1, char>::type, mp_push_front<L1, char>>));
+
+    BOOST_TEST_EQ((mpl::size<L1>::type::value), mp_size<L1>::value);
+
+    // algorithms
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::transform<L1, std::add_pointer<mpl::_1>>::type, mp_transform<add_pointer_t, L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::reverse<L1>::type, mp_reverse<L1>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::remove<L1, int>::type, mp_remove<L1, int>>));
+
+    using L2 = typename mpl::copy<L1, mpl::back_inserter<mpl::vector<>>>::type;
+    using L3 = typename mpl::copy<L2, mpl::back_inserter<mp_clear<L1>>>::type;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<L1, L3>));
+}
+
+int main()
+{
+    using boost::mp11::mp_list;
+
+    test<mp_list<int, void, float>>();
+    test<std::tuple<int, long, float>>(); // MPL instantiates the tuple, so no 'void'
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mpl_list.cpp b/src/boost/libs/mp11/test/mpl_list.cpp
new file mode 100644
index 000000000..dfdb44ebf
--- /dev/null
+++ b/src/boost/libs/mp11/test/mpl_list.cpp
@@ -0,0 +1,36 @@
+
+// Copyright 2017, 2019 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/mpl_list.hpp>
+#include <boost/mp11/list.hpp>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    namespace mpl = boost::mpl;
+    using namespace boost::mp11;
+
+    using L1 = mp_list<void, int, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<0>>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<1>>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<2>>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 0>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 1>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 2>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_EQ((mpl::size<L1>::type::value), mp_size<L1>::value);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mpl_tuple.cpp b/src/boost/libs/mp11/test/mpl_tuple.cpp
new file mode 100644
index 000000000..d85c36c0b
--- /dev/null
+++ b/src/boost/libs/mp11/test/mpl_tuple.cpp
@@ -0,0 +1,36 @@
+
+// Copyright 2017, 2019 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/mpl_tuple.hpp>
+#include <tuple>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+
+#include <boost/core/lightweight_test_trait.hpp>
+
+int main()
+{
+    namespace mpl = boost::mpl;
+    using namespace boost::mp11;
+
+    using L1 = std::tuple<char, int, float>;
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<0>>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<1>>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at<L1, mpl::int_<2>>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 0>::type, mp_at_c<L1, 0>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 1>::type, mp_at_c<L1, 1>>));
+    BOOST_TEST_TRAIT_TRUE((std::is_same<typename mpl::at_c<L1, 2>::type, mp_at_c<L1, 2>>));
+
+    BOOST_TEST_EQ((mpl::size<L1>::type::value), mp_size<L1>::value);
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/mpl_version.cpp b/src/boost/libs/mp11/test/mpl_version.cpp
new file mode 100644
index 000000000..f0d4c1bc1
--- /dev/null
+++ b/src/boost/libs/mp11/test/mpl_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/mpl.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/set_version.cpp b/src/boost/libs/mp11/test/set_version.cpp
new file mode 100644
index 000000000..057a251c6
--- /dev/null
+++ b/src/boost/libs/mp11/test/set_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/set.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/tuple_apply.cpp b/src/boost/libs/mp11/test/tuple_apply.cpp
new file mode 100644
index 000000000..dc5095927
--- /dev/null
+++ b/src/boost/libs/mp11/test/tuple_apply.cpp
@@ -0,0 +1,136 @@
+
+// Copyright 2015, 2017 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <tuple>
+#include <memory>
+#include <utility>
+#include <array>
+
+int main()
+{
+    using boost::mp11::tuple_apply;
+
+    {
+        std::tuple<int, short, char> tp{ 1, 2, 3 };
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, tp );
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::tuple<int, short, char> const tp{ 1, 2, 3 };
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, tp );
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 8
+#else
+
+    {
+        std::tuple<std::unique_ptr<int>, std::unique_ptr<int>, std::unique_ptr<int>> tp{ std::unique_ptr<int>(new int(1)), std::unique_ptr<int>(new int(2)), std::unique_ptr<int>(new int(3)) };
+
+        int s = tuple_apply( [&]( std::unique_ptr<int> px, std::unique_ptr<int> py, std::unique_ptr<int> pz ){ return 100 * *px + 10 * *py + *pz; }, std::move(tp) );
+        BOOST_TEST_EQ( s, 123 );
+    }
+
+#endif
+
+    {
+        std::pair<int, short> tp{ 1, 2 };
+
+        {
+            int s = tuple_apply( [&]( int x, int y ){ return 10 * x + y; }, tp );
+            BOOST_TEST_EQ( s, 12 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y ){ return 10 * x + y; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 12 );
+        }
+    }
+
+    {
+        std::pair<int, short> const tp{ 1, 2 };
+
+        {
+            int s = tuple_apply( [&]( int x, int y ){ return 10 * x + y; }, tp );
+            BOOST_TEST_EQ( s, 12 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y ){ return 10 * x + y; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 12 );
+        }
+    }
+
+    {
+        std::array<int, 3> tp{{ 1, 2, 3 }};
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, tp );
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::array<int, 3> const tp{{ 1, 2, 3 }};
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, tp );
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = tuple_apply( [&]( int x, int y, int z ){ return 100 * x + 10 * y + z; }, std::move(tp) );
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::tuple<> tp;
+
+        BOOST_TEST_EQ( tuple_apply( []{ return 11; }, tp ), 11 );
+        BOOST_TEST_EQ( tuple_apply( []{ return 12; }, std::move( tp ) ), 12 );
+    }
+
+    {
+        std::array<int, 0> tp;
+
+        BOOST_TEST_EQ( tuple_apply( []{ return 11; }, tp ), 11 );
+        BOOST_TEST_EQ( tuple_apply( []{ return 12; }, std::move( tp ) ), 12 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/tuple_apply_cx.cpp b/src/boost/libs/mp11/test/tuple_apply_cx.cpp
new file mode 100644
index 000000000..6f2f4e5ea
--- /dev/null
+++ b/src/boost/libs/mp11/test/tuple_apply_cx.cpp
@@ -0,0 +1,77 @@
+
+// Copyright 2015 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+// Technically std::tuple isn't constexpr enabled in C++11, but it works with libstdc++
+
+#if defined( BOOST_MP11_NO_CONSTEXPR ) || ( !defined( __GLIBCXX__ ) && __cplusplus < 201400L )
+
+int main() {}
+
+#else
+
+#include <tuple>
+#include <array>
+#include <utility>
+
+constexpr int f( int x, int y, int z )
+{
+    return x * 100 + y * 10 + z;
+}
+
+constexpr int g( int x, int y )
+{
+    return x * 10 + y;
+}
+
+constexpr int h()
+{
+    return 11;
+}
+
+int main()
+{
+    {
+        constexpr std::tuple<int, short, char> tp{ 1, 2, 3 };
+        constexpr auto r = boost::mp11::tuple_apply( f, tp );
+        static_assert( r == 123, "r == 123" );
+    }
+
+    {
+        constexpr std::pair<short, char> tp{ 1, 2 };
+        constexpr auto r = boost::mp11::tuple_apply( g, tp );
+        static_assert( r == 12, "r == 12" );
+    }
+
+    {
+        constexpr std::array<short, 3> tp{{ 1, 2, 3 }};
+        constexpr auto r = boost::mp11::tuple_apply( f, tp );
+        static_assert( r == 123, "r == 123" );
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 9
+// "error: default initialization of an object of const type 'const std::tuple<>' without a user-provided default constructor"
+#else
+
+    {
+        constexpr std::tuple<> tp;
+        constexpr auto r = boost::mp11::tuple_apply( h, tp );
+        static_assert( r == 11, "r == 11" );
+    }
+
+#endif
+}
+
+#endif
diff --git a/src/boost/libs/mp11/test/tuple_for_each.cpp b/src/boost/libs/mp11/test/tuple_for_each.cpp
new file mode 100644
index 000000000..a7e9428b6
--- /dev/null
+++ b/src/boost/libs/mp11/test/tuple_for_each.cpp
@@ -0,0 +1,175 @@
+
+// Copyright 2015 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <tuple>
+#include <memory>
+#include <utility>
+#include <array>
+
+int main()
+{
+    using boost::mp11::tuple_for_each;
+
+    {
+        std::tuple<int, short, char> tp{ 1, 2, 3 };
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::tuple<int, short, char> const tp{ 1, 2, 3 };
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 8
+#else
+
+    {
+        std::tuple<std::unique_ptr<int>, std::unique_ptr<int>, std::unique_ptr<int>> tp{ std::unique_ptr<int>(new int(1)), std::unique_ptr<int>(new int(2)), std::unique_ptr<int>(new int(3)) };
+
+        int s = 0;
+
+        tuple_for_each( std::move(tp), [&]( std::unique_ptr<int> p ){ s = s * 10 + *p; } );
+
+        BOOST_TEST_EQ( s, 123 );
+    }
+
+#endif
+
+    {
+        std::pair<int, short> tp{ 1, 2 };
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 12 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 12 );
+        }
+    }
+
+    {
+        std::pair<int, short> const tp{ 1, 2 };
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 12 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 12 );
+        }
+    }
+
+    {
+        std::array<int, 3> tp{{ 1, 2, 3 }};
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::array<int, 3> const tp{{ 1, 2, 3 }};
+
+        {
+            int s = 0;
+
+            tuple_for_each( tp, [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+
+        {
+            int s = 0;
+
+            tuple_for_each( std::move(tp), [&]( int x ){ s = s * 10 + x; } );
+
+            BOOST_TEST_EQ( s, 123 );
+        }
+    }
+
+    {
+        std::tuple<> tp;
+
+        BOOST_TEST_EQ( tuple_for_each( tp, 11 ), 11 );
+        BOOST_TEST_EQ( tuple_for_each( std::move( tp ), 12 ), 12 );
+    }
+
+    {
+        std::array<int, 0> tp;
+
+        BOOST_TEST_EQ( tuple_for_each( tp, 11 ), 11 );
+        BOOST_TEST_EQ( tuple_for_each( std::move( tp ), 12 ), 12 );
+    }
+
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/tuple_for_each_cx.cpp b/src/boost/libs/mp11/test/tuple_for_each_cx.cpp
new file mode 100644
index 000000000..f511e8145
--- /dev/null
+++ b/src/boost/libs/mp11/test/tuple_for_each_cx.cpp
@@ -0,0 +1,58 @@
+
+// Copyright 2015 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
+
+
+#if defined(_MSC_VER)
+#pragma warning( disable: 4244 ) // 'initializing': conversion from 'int' to 'char', possible loss of data
+#endif
+
+#include <boost/mp11/tuple.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+// Technically std::tuple isn't constexpr enabled in C++11, but it works with libstdc++
+
+#if defined( BOOST_MP11_NO_CONSTEXPR ) || ( !defined( __GLIBCXX__ ) && __cplusplus < 201400L )
+
+int main() {}
+
+#else
+
+#include <tuple>
+#include <type_traits>
+
+struct assert_is_integral
+{
+    template<class T> constexpr bool operator()( T ) const
+    {
+        static_assert( std::is_integral<T>::value, "T must be an integral type" );
+        return true;
+    }
+};
+
+int main()
+{
+    {
+        constexpr std::tuple<int, short, char> tp{ 1, 2, 3 };
+        constexpr auto r = boost::mp11::tuple_for_each( tp, assert_is_integral() );
+        (void)r;
+    }
+
+#if defined( __clang_major__ ) && __clang_major__ == 3 && __clang_minor__ < 9
+// "error: default initialization of an object of const type 'const std::tuple<>' without a user-provided default constructor"
+#else
+
+    {
+        constexpr std::tuple<> tp;
+        constexpr auto r = boost::mp11::tuple_for_each( tp, 11 );
+        static_assert( r == 11, "r == 11" );
+    }
+
+#endif
+}
+
+#endif
diff --git a/src/boost/libs/mp11/test/tuple_version.cpp b/src/boost/libs/mp11/test/tuple_version.cpp
new file mode 100644
index 000000000..d4d80f59e
--- /dev/null
+++ b/src/boost/libs/mp11/test/tuple_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/tuple.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/utility_version.cpp b/src/boost/libs/mp11/test/utility_version.cpp
new file mode 100644
index 000000000..64a84eae2
--- /dev/null
+++ b/src/boost/libs/mp11/test/utility_version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/utility.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}
diff --git a/src/boost/libs/mp11/test/version.cpp b/src/boost/libs/mp11/test/version.cpp
new file mode 100644
index 000000000..0b8d4a59b
--- /dev/null
+++ b/src/boost/libs/mp11/test/version.cpp
@@ -0,0 +1,17 @@
+
+// Copyright 2019 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/version.hpp>
+#include <boost/version.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST_EQ( BOOST_MP11_VERSION, BOOST_VERSION );
+    return boost::report_errors();
+}