cleanup

86 files changed, 4272 insertions, 8175 deletions

diff --git a/contrib/restricted/boost/boost/type_erasure/any.hpp b/contrib/restricted/boost/boost/type_erasure/any.hpp
deleted file mode 100644
index 2505c96908..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/any.hpp
+++ /dev/null
@@ -1,3022 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_ANY_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_ANY_HPP_INCLUDED
-
-#include <algorithm>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#   include <utility>  // std::forward, std::move
-#endif
-#include <boost/config.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/pair.hpp>
-#include <boost/mpl/map.hpp>
-#include <boost/mpl/reverse_fold.hpp>
-#include <boost/type_traits/decay.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/type_erasure/detail/access.hpp>
-#include <boost/type_erasure/detail/any_base.hpp>
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/detail/storage.hpp>
-#include <boost/type_erasure/detail/instantiate.hpp>
-#include <boost/type_erasure/config.hpp>
-#include <boost/type_erasure/binding.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/concept_interface.hpp>
-#include <boost/type_erasure/call.hpp>
-#include <boost/type_erasure/relaxed.hpp>
-#include <boost/type_erasure/param.hpp>
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4355)
-#pragma warning(disable:4521)
-#pragma warning(disable:4522) // multiple assignment operators specified
-#endif
-
-namespace boost {
-namespace type_erasure {
-
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-
-template<class Sig>
-struct constructible;
-
-template<class T>
-struct destructible;
-
-template<class T, class U>
-struct assignable;
-
-#endif
-
-namespace detail {
-
-#if defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-
-template<class Concept, class Base, class ID>
-struct choose_concept_interface
-{
-    typedef ::boost::type_erasure::concept_interface<Concept, Base, ID> type;
-};
-
-#else
-
-struct default_concept_interface
-{
-    template<class Concept, class Base, class ID>
-    using apply = ::boost::type_erasure::concept_interface<Concept, Base, ID>;
-};
-
-default_concept_interface boost_type_erasure_find_interface(...);
-
-template<class Concept, class Base, class ID>
-struct choose_concept_interface
-{
-    typedef decltype(boost_type_erasure_find_interface(::boost::declval<Concept>())) finder;
-    typedef typename finder::template apply<Concept, Base, ID> type;
-};
-
-#endif
-
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-
-template<class Derived, class Concept, class T>
-struct compute_bases
-{
-    typedef typename ::boost::mpl::reverse_fold<
-        typename ::boost::type_erasure::detail::collect_concepts<
-            Concept
-        >::type,
-        ::boost::type_erasure::any_base<Derived>,
-        ::boost::type_erasure::detail::choose_concept_interface<
-            ::boost::mpl::_2,
-            ::boost::mpl::_1,
-            T
-        >
-    >::type type;
-};
-
-#else
-
-template<class ID>
-struct compute_bases_f
-{
-    template<class Concept, class Base>
-    using apply = typename ::boost::type_erasure::detail::choose_concept_interface<Concept, Base, ID>::type;
-};
-
-template<class Derived, class Concept, class T>
-using compute_bases_t =
-    ::boost::mp11::mp_reverse_fold<
-        typename ::boost::type_erasure::detail::collect_concepts_t<
-            Concept
-        >,
-        ::boost::type_erasure::any_base<Derived>,
-        ::boost::type_erasure::detail::compute_bases_f<T>::template apply
-    >;
-
-template<class Derived, class Concept, class T>
-using compute_bases = ::boost::mpl::identity< ::boost::type_erasure::detail::compute_bases_t<Derived, Concept, T> >;
-
-#endif
-
-template<class T>
-T make(T*) { return T(); }
-
-// This dance is necessary to avoid errors calling
-// an ellipsis function with a non-trivially-copyable
-// argument.
-
-typedef char no;
-struct yes { no dummy[2]; };
-
-template<class Op>
-yes check_overload(const Op*);
-no check_overload(const void*);
-
-struct fallback {};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template<class T>
-fallback make_fallback(T&&, boost::mpl::false_)
-{
-    return fallback();
-}
-
-template<class T>
-T&& make_fallback(T&& arg, boost::mpl::true_)
-{
-    return std::forward<T>(arg);
-}
-
-#else
-
-template<class T>
-fallback make_fallback(const T&, boost::mpl::false_)
-{
-    return fallback();
-}
-
-template<class T>
-const T& make_fallback(const T& arg, boost::mpl::true_)
-{
-    return arg;
-}
-
-#endif
-
-template<class T>
-struct is_any : ::boost::mpl::false_ {};
-
-template<class Concept, class T>
-struct is_any<any<Concept, T> > : ::boost::mpl::true_ {};
-
-#ifdef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-
-template<class Any, class... U>
-struct has_constructor :
-    ::boost::mpl::bool_<
-        sizeof(
-            ::boost::type_erasure::detail::check_overload(
-                ::boost::declval<Any&>().
-                    _boost_type_erasure_deduce_constructor(::boost::declval<U>()...)
-            )
-        ) == sizeof(::boost::type_erasure::detail::yes)
-    >
-{};
-
-template<class Any>
-using has_copy_constructor =
-    ::boost::type_erasure::is_subconcept<
-        ::boost::type_erasure::constructible<
-            typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type const&)
-        >,
-        typename ::boost::type_erasure::concept_of<Any>::type
-    >;
-
-template<class Any>
-using has_move_constructor =
-    ::boost::type_erasure::is_subconcept<
-        ::boost::type_erasure::constructible<
-            typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type &&)
-        >,
-        typename ::boost::type_erasure::concept_of<Any>::type
-    >;
-
-template<class Any>
-using has_mutable_copy_constructor =
-    ::boost::type_erasure::is_subconcept<
-        ::boost::type_erasure::constructible<
-            typename ::boost::type_erasure::placeholder_of<Any>::type(typename ::boost::type_erasure::placeholder_of<Any>::type &)
-        >,
-        typename ::boost::type_erasure::concept_of<Any>::type
-    >;
-
-struct empty {};
-
-template<class T>
-struct is_binding_arg : ::boost::mpl::false_ {};
-template<class T>
-struct is_binding_arg<binding<T> > : ::boost::mpl::true_ {};
-template<class T>
-struct is_binding_arg<binding<T>&&> : ::boost::mpl::true_ {};
-template<class T>
-struct is_binding_arg<binding<T>&> : ::boost::mpl::true_ {};
-template<class T>
-struct is_binding_arg<binding<T> const&> : ::boost::mpl::true_ {};
-
-template<class T>
-struct is_static_binding_arg : ::boost::mpl::false_ {};
-template<class T>
-struct is_static_binding_arg<static_binding<T> > : ::boost::mpl::true_ {};
-template<class T>
-struct is_static_binding_arg<static_binding<T>&&> : ::boost::mpl::true_ {};
-template<class T>
-struct is_static_binding_arg<static_binding<T>&> : ::boost::mpl::true_ {};
-template<class T>
-struct is_static_binding_arg<static_binding<T> const&> : ::boost::mpl::true_ {};
-
-template<class T>
-struct is_any_arg : ::boost::mpl::false_ {};
-template<class Concept, class T>
-struct is_any_arg<any<Concept, T> > : ::boost::mpl::true_ {};
-template<class Concept, class T>
-struct is_any_arg<any<Concept, T>&&> : ::boost::mpl::true_ {};
-template<class Concept, class T>
-struct is_any_arg<any<Concept, T>&> : ::boost::mpl::true_ {};
-template<class Concept, class T>
-struct is_any_arg<any<Concept, T> const&> : ::boost::mpl::true_ {};
-
-template<class T>
-struct safe_concept_of;
-template<class Concept, class T>
-struct safe_concept_of<any<Concept, T> > { typedef Concept type; };
-template<class Concept, class T>
-struct safe_concept_of<any<Concept, T>&&> { typedef Concept type; };
-template<class Concept, class T>
-struct safe_concept_of<any<Concept, T>&> { typedef Concept type; };
-template<class Concept, class T>
-struct safe_concept_of<any<Concept, T> const&> { typedef Concept type; };
-
-template<class T>
-struct safe_placeholder_of;
-template<class Concept, class T>
-struct safe_placeholder_of<any<Concept, T> > { typedef T type; };
-template<class Concept, class T>
-struct safe_placeholder_of<any<Concept, T>&&> { typedef T type; };
-template<class Concept, class T>
-struct safe_placeholder_of<any<Concept, T>&> { typedef T type; };
-template<class Concept, class T>
-struct safe_placeholder_of<any<Concept, T> const&> { typedef T type; };
-
-template<class T>
-using safe_placeholder_t = ::boost::remove_cv_t< ::boost::remove_reference_t<typename safe_placeholder_of<T>::type> >;
-
-}
-
-// Enables or deletes the copy/move constructors depending on the Concept.
-template<class Base, class Enable = void>
-struct any_constructor_control : Base
-{
-    using Base::Base;
-};
-
-template<class Base>
-struct any_constructor_control<
-    Base,
-    typename boost::enable_if_c<
-        !::boost::type_erasure::detail::has_copy_constructor<Base>::value &&
-        ::boost::type_erasure::detail::has_move_constructor<Base>::value &&
-        ::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value
-    >::type
-> : Base
-{
-    using Base::Base;
-    any_constructor_control() = default;
-    any_constructor_control(any_constructor_control&) = default;
-    any_constructor_control(any_constructor_control&&) = default;
-    any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control &&) = default;
-};
-
-template<class Base>
-struct any_constructor_control<
-    Base,
-    typename boost::enable_if_c<
-        !::boost::type_erasure::detail::has_copy_constructor<Base>::value &&
-        !::boost::type_erasure::detail::has_move_constructor<Base>::value &&
-        ::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value
-    >::type
-> : Base
-{
-    using Base::Base;
-    any_constructor_control() = default;
-    any_constructor_control(any_constructor_control&) = default;
-    any_constructor_control(any_constructor_control&&) = delete;
-    any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control &&) = default;
-};
-
-template<class Base>
-struct any_constructor_control<
-    Base,
-    typename boost::enable_if_c<
-        !::boost::type_erasure::detail::has_copy_constructor<Base>::value &&
-        ::boost::type_erasure::detail::has_move_constructor<Base>::value &&
-        !::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value
-    >::type
-> : Base
-{
-    using Base::Base;
-    any_constructor_control() = default;
-    any_constructor_control(any_constructor_control const&) = delete;
-    any_constructor_control(any_constructor_control&&) = default;
-    any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control &&) = default;
-};
-
-template<class Base>
-struct any_constructor_control<
-    Base,
-    typename boost::enable_if_c<
-        !::boost::type_erasure::detail::has_copy_constructor<Base>::value &&
-        !::boost::type_erasure::detail::has_move_constructor<Base>::value &&
-        !::boost::type_erasure::detail::has_mutable_copy_constructor<Base>::value
-    >::type
-> : Base
-{
-    using Base::Base;
-    any_constructor_control() = default;
-    any_constructor_control(any_constructor_control const&) = delete;
-    any_constructor_control(any_constructor_control&&) = delete;
-    any_constructor_control& operator=(any_constructor_control const& other) { static_cast<Base&>(*this) = static_cast<Base const&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control & other) { static_cast<Base&>(*this) = static_cast<Base&>(other); return *this; }
-    any_constructor_control& operator=(any_constructor_control &&) = default;
-};
-
-template<class Concept, class T>
-struct any_constructor_impl :
-    ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, T>,
-        Concept,
-        T
-    >::type
-{
-    typedef typename ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, T>,
-        Concept,
-        T
-    >::type _boost_type_erasure_base;
-    // Internal constructors
-    typedef ::boost::type_erasure::binding<Concept> _boost_type_erasure_table_type;
-    any_constructor_impl(const ::boost::type_erasure::detail::storage& data_arg, const _boost_type_erasure_table_type& table_arg)
-      : _boost_type_erasure_table(table_arg),
-        _boost_type_erasure_data(data_arg)
-    {}
-    any_constructor_impl(::boost::type_erasure::detail::storage&& data_arg, const _boost_type_erasure_table_type& table_arg)
-      : _boost_type_erasure_table(table_arg),
-        _boost_type_erasure_data(data_arg)
-    {}
-    // default constructor
-    any_constructor_impl()
-    {
-        BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>));
-        _boost_type_erasure_data.data = 0;
-    }
-    // capturing constructor
-    template<class U,
-        typename ::boost::enable_if_c<
-            !::boost::type_erasure::detail::is_any_arg<U>::value &&
-            !::boost::type_erasure::detail::is_binding_arg<U>::value &&
-            !::boost::type_erasure::detail::is_static_binding_arg<U>::value
-        >::type* = nullptr
-    >
-    any_constructor_impl(U&& data_arg)
-      : _boost_type_erasure_table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, ::boost::decay_t<U>),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, ::boost::decay_t<U> > >
-            >()
-        )),
-        _boost_type_erasure_data(std::forward<U>(data_arg))
-    {}
-    template<class U, class Map,
-        typename ::boost::enable_if_c<
-            !::boost::type_erasure::detail::is_any_arg<U>::value &&
-            !::boost::type_erasure::detail::is_binding_arg<U>::value &&
-            !::boost::type_erasure::detail::is_static_binding_arg<U>::value
-        >::type* = nullptr
-    >
-    any_constructor_impl(U&& data_arg, const static_binding<Map>& b)
-      : _boost_type_erasure_table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            b
-        )),
-        _boost_type_erasure_data(std::forward<U>(data_arg))
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, ::boost::decay_t<U> >));
-    }
-    // converting constructor
-    template<class U,
-        typename ::boost::enable_if_c<
-            ::boost::type_erasure::is_subconcept<
-                Concept, typename ::boost::type_erasure::detail::safe_concept_of<U>::type,
-                typename ::boost::mpl::if_c< ::boost::is_same<T, ::boost::type_erasure::detail::safe_placeholder_t<U> >::value,
-                    void,
-                    ::boost::mpl::map1<
-                        ::boost::mpl::pair<T, ::boost::type_erasure::detail::safe_placeholder_t<U> >
-                    >
-                >::type
-            >::value
-        >::type* = nullptr
-    >
-    any_constructor_impl(U&& other)
-      : _boost_type_erasure_table(
-            ::boost::type_erasure::detail::access::table(other),
-            typename ::boost::mpl::if_c< ::boost::is_same<T, ::boost::type_erasure::detail::safe_placeholder_t<U> >::value,
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-                ::boost::type_erasure::detail::substitution_map< ::boost::mpl::map0<> >,
-#else
-                ::boost::type_erasure::detail::make_identity_placeholder_map<Concept>,
-#endif
-                ::boost::mpl::map1<
-                    ::boost::mpl::pair<
-                        T,
-                        ::boost::type_erasure::detail::safe_placeholder_t<U>
-                    >
-                >
-            >::type()
-        ),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0
-            ), std::forward<U>(other))
-        )
-    {}
-    template<class U,
-        typename ::boost::enable_if_c<
-            ::boost::type_erasure::detail::is_any_arg<U>::value
-        >::type* = nullptr
-    >
-    any_constructor_impl(U&& other, const binding<Concept>& binding_arg)
-      : _boost_type_erasure_table(binding_arg),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0
-            ), std::forward<U>(other))
-        )
-    {}
-    template<class U, class Map,
-        typename ::boost::enable_if_c<
-            ::boost::type_erasure::is_subconcept<
-                Concept, typename ::boost::type_erasure::detail::safe_concept_of<U>::type,
-                Map
-            >::value
-        >::type* = nullptr
-    >
-    any_constructor_impl(U&& other, const static_binding<Map>& binding_arg)
-      : _boost_type_erasure_table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(std::forward<U>(other)) : 0
-            ), std::forward<U>(other))
-        )
-    {}
-    // copy and move constructors are a special case of the converting
-    // constructors, but must be defined separately to keep C++ happy.
-    any_constructor_impl(const any_constructor_impl& other)
-      : _boost_type_erasure_table(
-            ::boost::type_erasure::detail::access::table(other)
-        ),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(
-                    static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type const&>(other)) : 0
-            ), other)
-        )
-    {}
-    any_constructor_impl(any_constructor_impl& other)
-      : _boost_type_erasure_table(
-            ::boost::type_erasure::detail::access::table(other)
-        ),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(
-                    static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type &>(other)) : 0
-            ), other)
-        )
-    {}
-    any_constructor_impl(any_constructor_impl&& other)
-      : _boost_type_erasure_table(
-            ::boost::type_erasure::detail::access::table(other)
-        ),
-        _boost_type_erasure_data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(
-                    static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type &&>(other)) : 0
-            ), std::move(other))
-        )
-    {}
-
-    template<class R, class... A, class... U>
-    const _boost_type_erasure_table_type& _boost_type_erasure_extract_table(
-        ::boost::type_erasure::constructible<R(A...)>*,
-        U&&... u)
-    {
-        return *::boost::type_erasure::detail::extract_table(static_cast<void(*)(A...)>(0), u...);
-    }
-    // forwarding constructor
-    template<class... U,
-        typename ::boost::enable_if_c<
-            ::boost::type_erasure::detail::has_constructor<any_constructor_impl, U...>::value
-        >::type* = nullptr
-    >
-    explicit any_constructor_impl(U&&... u)
-      : _boost_type_erasure_table(
-            _boost_type_erasure_extract_table(
-                false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0,
-                std::forward<U>(u)...
-            )
-        ),
-        _boost_type_erasure_data(
-            ::boost::type_erasure::call(
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0
-                ),
-                std::forward<U>(u)...
-            )
-        )
-    {}
-    template<class... U,
-        typename ::boost::enable_if_c<
-            ::boost::type_erasure::detail::has_constructor<any_constructor_impl, U...>::value
-        >::type* = nullptr
-    >
-    explicit any_constructor_impl(const binding<Concept>& binding_arg, U&&... u)
-      : _boost_type_erasure_table(binding_arg),
-        _boost_type_erasure_data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U>(u)...) : 0
-                ),
-                std::forward<U>(u)...
-            )
-        )
-    {}
-
-    // The assignment operator and destructor must be defined here rather
-    // than in any to avoid implicitly deleting the move constructor.
-
-    any_constructor_impl& operator=(const any_constructor_impl& other)
-    {
-        static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign(
-            static_cast<const typename _boost_type_erasure_base::_boost_type_erasure_derived_type&>(other));
-        return *this;
-    }
-
-    any_constructor_impl& operator=(any_constructor_impl& other)
-    {
-        static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign(
-            static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type&>(other));
-        return *this;
-    }
-
-    any_constructor_impl& operator=(any_constructor_impl&& other)
-    {
-        static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type*>(this)->_boost_type_erasure_resolve_assign(
-            static_cast<typename _boost_type_erasure_base::_boost_type_erasure_derived_type&&>(other));
-        return *this;
-    }
-
-    ~any_constructor_impl()
-    {
-        _boost_type_erasure_table.template find<
-            ::boost::type_erasure::destructible<T>
-        >()(_boost_type_erasure_data);
-    }
-
-protected:
-    friend struct ::boost::type_erasure::detail::access;
-
-    _boost_type_erasure_table_type _boost_type_erasure_table;
-    ::boost::type_erasure::detail::storage _boost_type_erasure_data;
-};
-
-namespace detail {
-
-#endif
-
-template<class T>
-struct is_rvalue_for_any : 
-    ::boost::mpl::not_<
-        ::boost::is_lvalue_reference<T>
-    >
-{};
-
-template<class C, class P>
-struct is_rvalue_for_any<any<C, P> > :
-    ::boost::mpl::not_<
-        ::boost::is_lvalue_reference<P>
-    >
-{};
-
-}
-
-/**
- * The class template @ref any can store any object that
- * models a specific \Concept.  It dispatches all
- * the functions defined by the \Concept to the contained type
- * at runtime.
- *
- * \tparam Concept The \Concept that the stored type should model.
- * \tparam T A @ref placeholder specifying which type this is.
- *
- * \see concept_of, placeholder_of, \any_cast, \is_empty, \binding_of, \typeid_of
- */
-template<class Concept, class T = _self>
-class any :
-#ifdef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-    public ::boost::type_erasure::any_constructor_control<
-        ::boost::type_erasure::any_constructor_impl<
-
-            Concept,
-            T
-        >
-    >
-#else
-    public ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, T>,
-        Concept,
-        T
-    >::type
-#endif
-{
-    typedef ::boost::type_erasure::binding<Concept> table_type;
-public:
-    /** INTERNAL ONLY */
-    typedef Concept _boost_type_erasure_concept_type;
-
-#if defined(BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS)
-    using _boost_type_erasure_base = ::boost::type_erasure::any_constructor_control<
-        ::boost::type_erasure::any_constructor_impl<
-            Concept,
-            T
-        >
-    >;
-    using _boost_type_erasure_base::_boost_type_erasure_base;
-#else
-
-    /** INTERNAL ONLY */
-    any(const ::boost::type_erasure::detail::storage& data_arg, const table_type& table_arg)
-      : table(table_arg),
-        data(data_arg)
-    {}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** INTERNAL ONLY */
-    any(::boost::type_erasure::detail::storage&& data_arg, const table_type& table_arg)
-      : table(table_arg),
-        data(data_arg)
-    {}
-#endif
-    /**
-     * Constructs an empty @ref any.
-     *
-     * Except as otherwise noted, all operations on an
-     * empty @ref any result in a @ref bad_function_call exception.
-     * The copy-constructor of an empty @ref any creates another
-     * null @ref any.  The destructor of an empty @ref any is a no-op.
-     * Comparison operators treat all empty @ref any "anys" as equal.
-     * \typeid_of applied to an empty @ref any returns @c typeid(void).
-     *
-     * An @ref any which does not include @ref relaxed in its
-     * \Concept can never be null.
-     *
-     * \pre @ref relaxed must be in @c Concept.
-     *
-     * \throws Nothing.
-     *
-     * @see \is_empty
-     */
-    any()
-    {
-        BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>));
-        data.data = 0;
-    }
-
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
-    template<class U>
-    any(const U& data_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, U> >
-            >()
-        )),
-        data(data_arg)
-    {}
-    template<class U, class Map>
-    any(const U& data_arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-    }
-
-#else
-
-    /**
-     * Constructs an @ref any to hold a copy of @c data.
-     * The @c Concept will be instantiated with the
-     * placeholder @c T bound to U.
-     *
-     * \param data The object to store in the @ref any.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c U must be \CopyConstructible.
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of @c U throws.
-     *
-     * \note This constructor never matches if the argument is
-     *       an @ref any, @ref binding, or @ref static_binding.
-     */
-    template<class U>
-    any(U&& data_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type> >
-            >()
-        )),
-        data(std::forward<U>(data_arg))
-    {}
-    /**
-     * Constructs an @ref any to hold a copy of @c data
-     * with explicitly specified placeholder bindings.
-     *
-     * \param data The object to store in the @ref any.
-     * \param binding Specifies the types that
-     *        all the placeholders should bind to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c U must be \CopyConstructible.
-     * \pre @c Map is an MPL map with an entry for every
-     *         non-deduced placeholder referred to by @c Concept.
-     * \pre @c @c T must map to @c U in @c Map.
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of @c U throws.
-     *
-     * \note This constructor never matches if the argument is an @ref any.
-     */
-    template<class U, class Map>
-    any(U&& data_arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(std::forward<U>(data_arg))
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>));
-    }
-
-#endif
-
-    // Handle array/function-to-pointer decay
-    /** INTERNAL ONLY */
-    template<class U>
-    any(U* data_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U*),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, U*> >
-            >()
-        )),
-        data(data_arg)
-    {}
-    /** INTERNAL ONLY */
-    template<class U, class Map>
-    any(U* data_arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U*>));
-    }
-    /**
-     * Copies an @ref any.
-     *
-     * \param other The object to make a copy of.
-     *
-     * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>".
-     *     (This is included in @ref copy_constructible "copy_constructible<T>")
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of the contained type throws.
-     */
-    any(const any& other)
-      : table(other.table),
-        data(::boost::type_erasure::call(constructible<T(const T&)>(), other))
-    {}
-    /**
-     * Upcasts from an @ref any with stricter requirements to
-     * an @ref any with weaker requirements.
-     *
-     * \param other The object to make a copy of.
-     *
-     * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>".
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of the contained type throws.
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other)
-      : table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_const<
-                        typename ::boost::remove_reference<Tag2>::type
-                    >::type
-                >
-            >()
-        ),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to make a copy of.
-     * \param binding Specifies the mapping between the placeholders
-     *        used by the two concepts.
-     *
-     * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>".
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of the contained type throws.
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to make a copy of.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre @c Concept must contain @ref constructible "constructible<T(const T&)>".
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws std::bad_alloc or whatever that the copy
-     *         constructor of the contained type throws.
-     *
-     * \warning This constructor is potentially dangerous, as it cannot
-     *          check at compile time whether the arguments match.
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other, const binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-    /**
-     * Calls a constructor of the contained type.  The bindings
-     * will be deduced from the arguments.
-     *
-     * \param arg The arguments to be passed to the underlying constructor.
-     *
-     * \pre @c Concept must contain an instance of @ref constructible which
-     *      can be called with these arguments.
-     * \pre At least one of the arguments must by an @ref any with the
-     *      same @c Concept as this.
-     * \pre The bindings of all the arguments that are @ref any's, must
-     *      be the same.
-     *
-     * \throws std::bad_alloc or whatever that the
-     *         constructor of the contained type throws.
-     *
-     * \note This constructor is never chosen if any other constructor
-     *       can be called instead.
-     */
-    template<class... U>
-    explicit any(U&&... arg);
-
-    /**
-     * Calls a constructor of the contained type.
-     *
-     * \param binding Specifies the bindings of placeholders to actual types.
-     * \param arg The arguments to be passed to the underlying constructor.
-     *
-     * \pre @c Concept must contain a matching instance of @ref constructible.
-     * \pre The contained type of every argument that is an @ref any, must
-     *      be the same as that specified by @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws std::bad_alloc or whatever that the
-     *         constructor of the contained type throws.
-     */
-    template<class... U>
-    explicit any(const binding<Concept>& binding_arg, U&&... arg)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(arg...) : 0
-            )(arg...)
-        )
-    {}
-
-#else
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    any(any&& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(std::move(other)) : 0
-            ), std::move(other))
-        )
-    {}
-    any(any& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other)
-      : table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_const<
-                        typename ::boost::remove_reference<Tag2>::type
-                    >::type
-                >
-            >()
-        ),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other)
-      : table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_const<
-                        typename ::boost::remove_reference<Tag2>::type
-                    >::type
-                >
-            >()
-        ),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? other._boost_type_erasure_deduce_constructor(std::move(other)) : 0
-            ), std::move(other))
-        )
-    {}
-#endif
-    // construction from a reference
-    any(const any<Concept, T&>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-    any(any<Concept, T&>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    any(any<Concept, T&>&& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-#endif
-    any(const any<Concept, const T&>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-    any(any<Concept, const T&>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    any(any<Concept, const T&>&& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-#endif
-
-    // disambiguating overloads
-    template<class U, class Map>
-    any(U* data_arg, static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U*>));
-    }
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<class U, class Map>
-    any(U& data_arg, static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-    }
-    template<class U, class Map>
-    any(const U& data_arg, static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-    }
-    template<class U, class Map>
-    any(U& data_arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-    }
-#endif
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<class U, class Map>
-    any(U* data_arg, static_binding<Map>&& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U*>));
-    }
-    template<class U, class Map>
-    any(U&& data_arg, static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>));
-    }
-    template<class U, class Map>
-    any(U&& data_arg, static_binding<Map>&& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        )),
-        data(data_arg)
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, typename ::boost::remove_cv<typename ::boost::remove_reference<U>::type>::type>));
-    }
-#endif
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>& other, static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2>& other, static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other, binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other, const binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other, binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>& other, static_binding<Map>&& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2>& other, static_binding<Map>&& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>&& other, static_binding<Map>&& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>&& other, static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>&& other, const static_binding<Map>& binding_arg)
-      : table(::boost::type_erasure::detail::access::table(other), binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other, binding<Concept>&& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other, binding<Concept>&& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), other)
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other, binding<Concept>&& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other, binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other, const binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(::boost::type_erasure::call(
-            constructible<
-                typename ::boost::remove_const<
-                    typename boost::remove_reference<Tag2>::type
-                >::type(const typename boost::remove_reference<Tag2>::type&)
-            >(), std::move(other))
-        )
-    {}
-#endif
-
-    // One argument is a special case.  The argument must be an any
-    // and the constructor must be explicit.
-    template<class Tag2>
-    explicit any(const any<Concept, Tag2>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-    template<class Tag2>
-    explicit any(any<Concept, Tag2>& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(other) : 0
-            ), other)
-        )
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<class Tag2>
-    explicit any(any<Concept, Tag2>&& other)
-      : table(::boost::type_erasure::detail::access::table(other)),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(std::move(other)) : 0
-            ), std::move(other))
-        )
-    {}
-#endif
-
-    explicit any(const binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::constructible<T()>()
-            )
-        )
-    {}
-    explicit any(binding<Concept>& binding_arg)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::constructible<T()>()
-            )
-        )
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-    explicit any(binding<Concept>&& binding_arg)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::constructible<T()>()
-            )
-        )
-    {}
-
-#endif
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
-    template<class R, class... A, class... U>
-    const table_type& _boost_type_erasure_extract_table(
-        ::boost::type_erasure::constructible<R(A...)>*,
-        U&&... u)
-    {
-        return *::boost::type_erasure::detail::extract_table(static_cast<void(*)(A...)>(0), u...);
-    }
-
-    template<class U0, class U1, class... U>
-    any(U0&& u0, U1&& u1, U&&... u)
-      : table(
-            _boost_type_erasure_extract_table(
-                false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...) : 0,
-                std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...
-            )
-        ),
-        data(
-            ::boost::type_erasure::call(
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...) : 0
-                ),
-                std::forward<U0>(u0), std::forward<U1>(u1), std::forward<U>(u)...
-            )
-        )
-    {}
-
-    template<class U0, class... U>
-    any(const binding<Concept>& binding_arg, U0&& u0, U&&... u)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0
-                ),
-                std::forward<U0>(u0), std::forward<U>(u)...
-            )
-        )
-    {}
-    
-    // disambiguating overloads
-    template<class U0, class... U>
-    any(binding<Concept>& binding_arg, U0&& u0, U&&... u)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0
-                ),
-                std::forward<U0>(u0), std::forward<U>(u)...
-            )
-        )
-    {}
-    template<class U0, class... U>
-    any(binding<Concept>&& binding_arg, U0&& u0, U&&... u)
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(std::forward<U0>(u0), std::forward<U>(u)...) : 0
-                ),
-                std::forward<U0>(u0), std::forward<U>(u)...
-            )
-        )
-    {}
-
-#else
-
-#include <boost/type_erasure/detail/construct.hpp>
-
-#endif
-
-#endif
-    
-    /** INTERNAL ONLY */
-    any& operator=(const any& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    /** INTERNAL ONLY */
-    any& operator=(any& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-
-#endif // BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<class U>
-    any& operator=(U& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    template<class U>
-    any& operator=(const U& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-#else
-#ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-    /** INTERNAL ONLY */
-    any& operator=(any&& other)
-    {
-        _boost_type_erasure_resolve_assign(std::move(other));
-        return *this;
-    }
-#endif
-    /**
-     * Assigns to an @ref any.
-     *
-     * If an appropriate overload of @ref assignable is not available
-     * and @ref relaxed is in @c Concept, falls back on
-     * constructing from @c other.
-     *
-     * \note If @c U is an @ref any, then this can decide dynamically
-     *       whether to use construction based on the type stored in other.
-     *
-     * \throws Whatever the assignment operator of the contained
-     *         type throws.  When falling back on construction,
-     *         throws @c std::bad_alloc or whatever the move (or copy)
-     *         constructor of the contained type throws.  In
-     *         this case move assignment provides the strong exception
-     *         guarantee.  When calling a (move) assignment operator
-     *         of the contained type, the exception guarantee is
-     *         whatever the contained type provides.
-     */
-    template<class U>
-    any& operator=(U&& other)
-    {
-        _boost_type_erasure_resolve_assign(std::forward<U>(other));
-        return *this;
-    }
-#endif
-
-#ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-    /**
-     * \pre @c Concept includes @ref destructible "destructible<T>".
-     */
-    ~any()
-    {
-        ::boost::type_erasure::detail::access::table(*this).template find<
-            ::boost::type_erasure::destructible<T>
-        >()(::boost::type_erasure::detail::access::data(*this));
-    }
-#endif
-
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
-    /** INTERNAL ONLY */
-    operator param<Concept, T&>() &
-    {
-        return param<Concept, T&>(
-            boost::type_erasure::detail::access::data(*this),
-            boost::type_erasure::detail::access::table(*this));
-    }
-    /** INTERNAL ONLY */
-    operator param<Concept, T&&>() && {
-        return param<Concept, T&&>(
-            boost::type_erasure::detail::access::data(*this),
-            boost::type_erasure::detail::access::table(*this));
-    }
-#endif
-private:
-#ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-    /** INTERNAL ONLY */
-    void _boost_type_erasure_swap(any& other)
-    {
-        ::std::swap(data, other.data);
-        ::std::swap(table, other.table);
-    }
-#else
-    void _boost_type_erasure_swap(any& other)
-    {
-        ::std::swap(this->_boost_type_erasure_data, other._boost_type_erasure_data);
-        ::std::swap(this->_boost_type_erasure_table, other._boost_type_erasure_table);
-    }
-#endif
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign(Other&& other)
-    {
-        _boost_type_erasure_assign_impl(
-            std::forward<Other>(other),
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    std::forward<Other>(other),
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_assign(std::forward<Other>(other))
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::type_erasure::is_relaxed<Concept>()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::true_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        any temp(std::forward<Other>(other));
-        _boost_type_erasure_swap(temp);
-    }
-#else
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign(Other& other)
-    {
-        _boost_type_erasure_assign_impl(
-            other,
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    other,
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_assign(other)
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::type_erasure::is_relaxed<Concept>()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, other);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        ::boost::mpl::true_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, other);
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        any temp(other);
-        _boost_type_erasure_swap(temp);
-    }
-#endif
-    /** INTERNAL ONLY */
-    template<class Concept2, class Tag2>
-    void _boost_type_erasure_resolve_assign(const any<Concept2, Tag2>& other)
-    {
-        _boost_type_erasure_resolve_assign_any(other);
-    }
-    /** INTERNAL ONLY */
-    template<class Concept2, class Tag2>
-    void _boost_type_erasure_resolve_assign(any<Concept2, Tag2>& other)
-    {
-        _boost_type_erasure_resolve_assign_any(other);
-    }
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** INTERNAL ONLY */
-    template<class Concept2, class Tag2>
-    void _boost_type_erasure_resolve_assign(any<Concept2, Tag2>&& other)
-    {
-        _boost_type_erasure_resolve_assign_any(std::move(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign_any(Other&& other)
-    {
-        _boost_type_erasure_assign_impl(
-            std::forward<Other>(other),
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    std::forward<Other>(other),
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_assign(std::forward<Other>(other))
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            false? this->_boost_type_erasure_deduce_constructor(
-                ::boost::type_erasure::detail::make_fallback(
-                    std::forward<Other>(other),
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_constructor(std::forward<Other>(other))
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::type_erasure::is_relaxed<Concept>()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        const void*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class Sig>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const void*,
-        const constructible<Sig>*,
-        ::boost::mpl::true_)
-    {
-        any temp(std::forward<Other>(other));
-        _boost_type_erasure_swap(temp);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U, class Sig>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        const constructible<Sig>*,
-        ::boost::mpl::true_)
-    {
-        if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other))  // const reference to other is enough!
-        {
-            ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, std::forward<Other>(other));
-        }
-        else
-        {
-            any temp(std::forward<Other>(other));
-            _boost_type_erasure_swap(temp);
-        }
-    }
-#else
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign_any(Other& other)
-    {
-        _boost_type_erasure_assign_impl(
-            other,
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    other,
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_assign(other)
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            false? this->_boost_type_erasure_deduce_constructor(
-                ::boost::type_erasure::detail::make_fallback(
-                    other,
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_constructor(other)
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::type_erasure::is_relaxed<Concept>()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        const void*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, other);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, other);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class Sig>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const void*,
-        const constructible<Sig>*,
-        ::boost::mpl::true_)
-    {
-        any temp(other);
-        _boost_type_erasure_swap(temp);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U, class Sig>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        const constructible<Sig>*,
-        ::boost::mpl::true_)
-    {
-        if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other))
-        {
-            ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, other);
-        }
-        else
-        {
-            any temp(other);
-            _boost_type_erasure_swap(temp);
-        }
-    }
-#endif
-    friend struct ::boost::type_erasure::detail::access;
-#ifndef BOOST_TYPE_ERASURE_SFINAE_FRIENDLY_CONSTRUCTORS
-    // The table has to be initialized first for exception
-    // safety in some constructors.
-    table_type table;
-    ::boost::type_erasure::detail::storage data;
-#else
-    template<class Concept2, class T2>
-    friend struct ::boost::type_erasure::any_constructor_impl;
-#endif
-};
-
-template<class Concept, class T>
-class any<Concept, T&> :
-    public ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, T&>,
-        Concept,
-        T
-    >::type
-{
-    typedef ::boost::type_erasure::binding<Concept> table_type;
-public:
-    /** INTERNAL ONLY */
-    typedef Concept _boost_type_erasure_concept_type;
-    /** INTERNAL ONLY */
-    any(const ::boost::type_erasure::detail::storage& data_arg,
-        const table_type& table_arg)
-      : data(data_arg),
-        table(table_arg)
-    {}
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     *
-     * \throws Nothing.
-     */
-    template<class U>
-    any(U& arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        ,  typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_const<U>,
-                ::boost::type_erasure::detail::is_any<U>
-            >
-        >::type* = 0
-#endif
-        )
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, U> >
-            >()
-        ))
-    {
-        data.data = ::boost::addressof(arg);
-    }
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     * \param binding Specifies the actual types that
-     *        all the placeholders should bind to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Map is an MPL map with an entry for every
-     *         non-deduced placeholder referred to by @c Concept.
-     *
-     * \throws Nothing.
-     */
-    template<class U, class Map>
-    any(U& arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        ))
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-        data.data = ::boost::addressof(arg);
-    }
-    /**
-     * Constructs an @ref any from another reference.
-     *
-     * \param other The reference to copy.
-     *
-     * \throws Nothing.
-     */
-    any(const any& other)
-      : data(other.data),
-        table(other.table)
-    {}
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-    any(any& other)
-      : data(other.data),
-        table(other.table)
-    {}
-#endif
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \throws Nothing.
-     */
-    any(any<Concept, T>& other)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other))
-    {}
-    /**
-     * Constructs an @ref any from another reference.
-     *
-     * \param other The reference to copy.
-     *
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2&>& other
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_same<Concept, Concept2>,
-                ::boost::is_const<Tag2>
-            >
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    Tag2
-                >
-            >())
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_same<Concept, Concept2>,
-                ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-            >
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_reference<Tag2>::type
-                >
-            >())
-    {}
-    /**
-     * Constructs an @ref any from another reference.
-     *
-     * \param other The reference to copy.
-     * \param binding Specifies the mapping between the two concepts.
-     *
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2&>& other, const static_binding<Map>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other), binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the mapping between the two concepts.
-     *
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other), binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another reference.
-     *
-     * \param other The reference to copy.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws Nothing.
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2&>& other, const binding<Concept>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<Tag2>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws Nothing.
-     */
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>& other, const binding<Concept>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(binding_arg)
-    {}
-    
-    /** INTERNAL ONLY */
-    any& operator=(const any& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    
-    /** INTERNAL ONLY */
-    any& operator=(any& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** INTERNAL ONLY */
-    any& operator=(any&& other)
-    {
-        _boost_type_erasure_resolve_assign(std::move(other));
-        return *this;
-    }
-    /**
-     * Assigns to an @ref any.
-     *
-     * If an appropriate overload of @ref assignable is not available
-     * and @ref relaxed is in @c Concept, falls back on
-     * constructing from @c other.
-     *
-     * \throws Whatever the assignment operator of the contained
-     *         type throws.  When falling back on construction,
-     *         can only throw @c std::bad_alloc if @c U is an @ref any
-     *         that uses a different @c Concept.  In this case assignment
-     *         provides the strong exception guarantee.  When
-     *         calling the assignment operator of the contained type,
-     *         the exception guarantee is whatever the contained type provides.
-     */
-    template<class U>
-    any& operator=(U&& other)
-    {
-        _boost_type_erasure_resolve_assign(std::forward<U>(other));
-        return *this;
-    }
-#else
-    template<class U>
-    any& operator=(U& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    
-    template<class U>
-    any& operator=(const U& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-#endif
-    
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
-    /** INTERNAL ONLY */
-    operator param<Concept, T&>() const { return param<Concept, T&>(data, table); }
-#endif
-private:
-
-    /** INTERNAL ONLY */
-    void _boost_type_erasure_swap(any& other)
-    {
-        ::std::swap(data, other.data);
-        ::std::swap(table, other.table);
-    }
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign(Other&& other)
-    {
-        _boost_type_erasure_assign_impl(
-            std::forward<Other>(other),
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    std::forward<Other>(other),
-                    ::boost::mpl::bool_<
-                    sizeof(
-                        ::boost::type_erasure::detail::check_overload(
-                            ::boost::declval<any&>().
-                            _boost_type_erasure_deduce_assign(std::forward<Other>(other))
-                        )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::mpl::and_<
-                ::boost::type_erasure::is_relaxed<Concept>,
-                ::boost::is_convertible<Other, any>
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1900))
-              , ::boost::mpl::not_<
-                    ::boost::type_erasure::detail::is_rvalue_for_any<Other>
-                >
-#endif
-            >()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::true_)
-    {
-        if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) {
-            ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, std::forward<Other>(other));
-        } else {
-            any temp(std::forward<Other>(other));
-            _boost_type_erasure_swap(temp);
-        }
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        any temp(std::forward<Other>(other));
-        _boost_type_erasure_swap(temp);
-    }
-#else
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign(Other& other)
-    {
-        _boost_type_erasure_assign_impl(
-            other,
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    other,
-                    ::boost::mpl::bool_<
-                        sizeof(
-                            ::boost::type_erasure::detail::check_overload(
-                                ::boost::declval<any&>().
-                                    _boost_type_erasure_deduce_assign(other)
-                            )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::mpl::and_<
-                ::boost::type_erasure::is_relaxed<Concept>,
-                ::boost::is_convertible<Other&, any>
-            >()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(assignable<T, U>(), *this, other);
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const assignable<T, U>*,
-        ::boost::mpl::true_)
-    {
-        if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) {
-            ::boost::type_erasure::unchecked_call(assignable<T, U>(), *this, other);
-        } else {
-            any temp(other);
-            _boost_type_erasure_swap(temp);
-        }
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_assign_impl(
-        Other& other,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        any temp(other);
-        _boost_type_erasure_swap(temp);
-    }
-#endif
-
-    friend struct ::boost::type_erasure::detail::access;
-    ::boost::type_erasure::detail::storage data;
-    table_type table;
-};
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-template<class Concept, class T>
-class any<Concept, const T&> :
-    public ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, const T&>,
-        Concept,
-        T
-    >::type
-{
-    typedef ::boost::type_erasure::binding<Concept> table_type;
-public:
-    /** INTERNAL ONLY */
-    typedef Concept _boost_type_erasure_concept_type;
-    /** INTERNAL ONLY */
-    any(const ::boost::type_erasure::detail::storage& data_arg,
-        const table_type& table_arg)
-      : data(data_arg),
-        table(table_arg)
-    {}
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     *
-     * \throws Nothing.
-     */
-    template<class U>
-    any(const U& arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, U> >
-            >()
-        ))
-    {
-        data.data = const_cast<void*>(static_cast<const void*>(::boost::addressof(arg)));
-    }
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     * \param binding Specifies the actual types that
-     *        all the placeholders should bind to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Map is an MPL map with an entry for every
-     *         non-deduced placeholder referred to by @c Concept.
-     *
-     * \throws Nothing.
-     */
-    template<class U, class Map>
-    any(const U& arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        ))
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-        data.data = const_cast<void*>(static_cast<const void*>(::boost::addressof(arg)));
-    }
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The reference to copy.
-     *
-     * \throws Nothing.
-     */
-    any(const any& other)
-      : data(other.data),
-        table(other.table)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The reference to copy.
-     *
-     * \throws Nothing.
-     */
-    any(const any<Concept, T&>& other)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other))
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \throws Nothing.
-     */
-    any(const any<Concept, T>& other)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other))
-    {}
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \throws Nothing.
-     */
-    any(const any<Concept, T&&>& other)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other))
-    {}
-#endif
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if< ::boost::is_same<Concept, Concept2> >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(
-            ::boost::type_erasure::detail::access::table(other),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_const<
-                        typename ::boost::remove_reference<Tag2>::type
-                    >::type
-                >
-            >())
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the mapping between the two concepts.
-     *
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2>& other, const static_binding<Map>& binding_arg)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other), binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws Nothing.
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2>& other, const binding<Concept>& binding_arg)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(binding_arg)
-    {}
-    
-    
-    /**
-     * Assigns to an @ref any.
-     *
-     * \pre @ref relaxed is in @c Concept.
-     *
-     * \throws Nothing.
-     */
-    any& operator=(const any& other)
-    {
-        BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>));
-        any temp(other);
-        _boost_type_erasure_swap(temp);
-        return *this;
-    }
-    /**
-     * Assigns to an @ref any.
-     *
-     * \pre @ref relaxed is in @c Concept.
-     *
-     * \throws std::bad_alloc.  Provides the strong exception guarantee.
-     */
-    template<class U>
-    any& operator=(const U& other)
-    {
-        BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>));
-        any temp(other);
-        _boost_type_erasure_swap(temp);
-        return *this;
-    }
-    
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
-    /** INTERNAL ONLY */
-    operator param<Concept, const T&>() const { return param<Concept, const T&>(data, table); }
-#endif
-private:
-    /** INTERNAL ONLY */
-    void _boost_type_erasure_swap(any& other)
-    {
-        ::std::swap(data, other.data);
-        ::std::swap(table, other.table);
-    }
-    friend struct ::boost::type_erasure::detail::access;
-    ::boost::type_erasure::detail::storage data;
-    table_type table;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template<class Concept, class T>
-class any<Concept, T&&> :
-    public ::boost::type_erasure::detail::compute_bases<
-        ::boost::type_erasure::any<Concept, T&&>,
-        Concept,
-        T
-    >::type
-{
-    typedef ::boost::type_erasure::binding<Concept> table_type;
-public:
-    /** INTERNAL ONLY */
-    typedef Concept _boost_type_erasure_concept_type;
-    /** INTERNAL ONLY */
-    any(const ::boost::type_erasure::detail::storage& data_arg,
-        const table_type& table_arg)
-      : data(data_arg),
-        table(table_arg)
-    {}
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     *
-     * \throws Nothing.
-     */
-    template<class U>
-    any(U&& arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        ,  typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_reference<U>,
-                ::boost::is_const<U>,
-                ::boost::type_erasure::detail::is_any<U>
-            >
-        >::type* = 0
-#endif
-        )
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, T, U),
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map1< ::boost::mpl::pair<T, U> >
-            >()
-        ))
-    {
-        data.data = ::boost::addressof(arg);
-    }
-    /**
-     * Constructs an @ref any from a reference.
-     *
-     * \param arg The object to bind the reference to.
-     * \param binding Specifies the actual types that
-     *        all the placeholders should bind to.
-     *
-     * \pre @c U is a model of @c Concept.
-     * \pre @c Map is an MPL map with an entry for every
-     *         non-deduced placeholder referred to by @c Concept.
-     *
-     * \throws Nothing.
-     */
-    template<class U, class Map>
-    any(U&& arg, const static_binding<Map>& binding_arg)
-      : table((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            binding_arg
-        ))
-    {
-        BOOST_MPL_ASSERT((::boost::is_same<
-            typename ::boost::mpl::at<Map, T>::type, U>));
-        data.data = ::boost::addressof(arg);
-    }
-    /**
-     * Constructs an @ref any from another rvalue reference.
-     *
-     * \param other The reference to copy.
-     *
-     * \throws Nothing.
-     */
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-    any(any&& other)
-      : data(other.data),
-        table(std::move(other.table))
-    {}
-    any(const any& other)
-      : data(other.data),
-        table(other.table)
-    {}
-#endif
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \throws Nothing.
-     */
-    any(any<Concept, T>&& other)
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(std::move(::boost::type_erasure::detail::access::table(other)))
-    {}
-    /**
-     * Constructs an @ref any from another rvalue reference.
-     *
-     * \param other The reference to copy.
-     *
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2&&>&& other
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_reference<Tag2>,
-                ::boost::is_same<Concept, Concept2>,
-                ::boost::is_const<Tag2>
-            >
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(
-            std::move(::boost::type_erasure::detail::access::table(other)),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    Tag2
-                >
-            >())
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     *
-     * \pre @c Concept must not refer to any non-deduced placeholder besides @c T.
-     * \pre After substituting @c T for @c Tag2, the requirements of
-     *      @c Concept2 must be a superset of the requirements of
-     *      @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::mpl::or_<
-                ::boost::is_same<Concept, Concept2>,
-                ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-            >
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(
-            std::move(::boost::type_erasure::detail::access::table(other)),
-            ::boost::mpl::map1<
-                ::boost::mpl::pair<
-                    T,
-                    typename ::boost::remove_reference<Tag2>::type
-                >
-            >())
-    {}
-    /**
-     * Constructs an @ref any from another reference.
-     *
-     * \param other The reference to copy.
-     * \param binding Specifies the mapping between the two concepts.
-     *
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(const any<Concept2, Tag2&&>& other, const static_binding<Map>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if< ::boost::is_const<Tag2> >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(std::move(::boost::type_erasure::detail::access::table(other)), binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the mapping between the two concepts.
-     *
-     * \pre @c Map must be an MPL map with keys for all the non-deduced
-     *      placeholders used by @c Concept and values for the corresponding
-     *      placeholders in @c Concept2.
-     * \pre After substituting placeholders according to @c Map, the
-     *      requirements of @c Concept2 must be a superset of the
-     *      requirements of @c Concept.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Tag2, class Map>
-    any(any<Concept2, Tag2>&& other, const static_binding<Map>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(::boost::type_erasure::detail::access::table(other), binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another rvalue reference.
-     *
-     * \param other The reference to copy.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws Nothing.
-     */
-    template<class Concept2, class Tag2>
-    any(const any<Concept2, Tag2&&>& other, const binding<Concept>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<Tag2>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(binding_arg)
-    {}
-    /**
-     * Constructs an @ref any from another @ref any.
-     *
-     * \param other The object to bind the reference to.
-     * \param binding Specifies the bindings of placeholders to actual types.
-     *
-     * \pre The type stored in @c other must match the type expected by
-     *      @c binding.
-     *
-     * \post binding_of(*this) == @c binding
-     *
-     * \throws Nothing.
-     */
-    template<class Concept2, class Tag2>
-    any(any<Concept2, Tag2>&& other, const binding<Concept>& binding_arg
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::disable_if<
-            ::boost::is_const<typename ::boost::remove_reference<Tag2>::type>
-        >::type* = 0
-#endif
-        )
-      : data(::boost::type_erasure::detail::access::data(other)),
-        table(binding_arg)
-    {}
-    
-    /** INTERNAL ONLY */
-    any& operator=(const any& other)
-    {
-        _boost_type_erasure_resolve_assign(other);
-        return *this;
-    }
-    
-    /**
-     * Assigns to an @ref any.
-     *
-     * If an appropriate overload of @ref assignable is not available
-     * and @ref relaxed is in @c Concept, falls back on
-     * constructing from @c other.
-     *
-     * \throws Whatever the assignment operator of the contained
-     *         type throws.  When falling back on construction,
-     *         can only throw @c std::bad_alloc if @c U is an @ref any
-     *         that uses a different @c Concept.  In this case assignment
-     *         provides the strong exception guarantee.  When
-     *         calling the assignment operator of the contained type,
-     *         the exception guarantee is whatever the contained type provides.
-     */
-    template<class U>
-    any& operator=(U&& other)
-    {
-        _boost_type_erasure_resolve_assign(std::forward<U>(other));
-        return *this;
-    }
-    
-#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
-    /** INTERNAL ONLY */
-    operator param<Concept, T&&>() const { return param<Concept, T&&>(data, table); }
-#endif
-private:
-
-    /** INTERNAL ONLY */
-    void _boost_type_erasure_swap(any& other)
-    {
-        ::std::swap(data, other.data);
-        ::std::swap(table, other.table);
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_resolve_assign(Other&& other)
-    {
-        _boost_type_erasure_assign_impl(
-            std::forward<Other>(other),
-            false? this->_boost_type_erasure_deduce_assign(
-                ::boost::type_erasure::detail::make_fallback(
-                    std::forward<Other>(other),
-                    ::boost::mpl::bool_<
-                    sizeof(
-                        ::boost::type_erasure::detail::check_overload(
-                            ::boost::declval<any&>().
-                            _boost_type_erasure_deduce_assign(std::forward<Other>(other))
-                        )
-                        ) == sizeof(::boost::type_erasure::detail::yes)
-                    >()
-                )
-            ) : 0,
-            ::boost::mpl::and_<
-                ::boost::type_erasure::is_relaxed<Concept>,
-                ::boost::is_convertible<Other, any>
-            >()
-        );
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::false_)
-    {
-        ::boost::type_erasure::call(
-            assignable<T, U>(),
-            // lose rvalueness of this
-            ::boost::type_erasure::param<Concept, T&>(data, table),
-            std::forward<Other>(other));
-    }
-    /** INTERNAL ONLY */
-    template<class Other, class U>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const assignable<T, U>*,
-        ::boost::mpl::true_)
-    {
-        if(::boost::type_erasure::check_match(assignable<T, U>(), *this, other)) {
-            ::boost::type_erasure::unchecked_call(
-                assignable<T, U>(),
-                // lose rvalueness of this
-                ::boost::type_erasure::param<Concept, T&>(data, table),
-                std::forward<Other>(other));
-        } else {
-            any temp(std::forward<Other>(other));
-            _boost_type_erasure_swap(temp);
-        }
-    }
-    /** INTERNAL ONLY */
-    template<class Other>
-    void _boost_type_erasure_assign_impl(
-        Other&& other,
-        const void*,
-        ::boost::mpl::true_)
-    {
-        any temp(std::forward<Other>(other));
-        _boost_type_erasure_swap(temp);
-    }
-
-    friend struct ::boost::type_erasure::detail::access;
-    ::boost::type_erasure::detail::storage data;
-    table_type table;
-};
-
-#endif
-
-#ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES
-template<class Concept, class T>
-using any_ref = any<Concept, T&>;
-template<class Concept, class T>
-using any_cref = any<Concept, const T&>;
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<class Concept, class T>
-using any_rvref = any<Concept, T&&>;
-#endif
-#endif
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/any_cast.hpp b/contrib/restricted/boost/boost/type_erasure/any_cast.hpp
deleted file mode 100644
index 939535c470..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/any_cast.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_ANY_CAST_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_ANY_CAST_HPP_INCLUDED
-
-#include <stdexcept>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/builtin.hpp>
-#include <boost/type_erasure/exception.hpp>
-#include <boost/type_erasure/detail/access.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-namespace detail {
-
-template<class Concept, class T>
-void* get_pointer(::boost::type_erasure::any<Concept, T>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class Concept, class T>
-const void* get_pointer(const ::boost::type_erasure::any<Concept, T>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class Concept, class T>
-void* get_pointer(::boost::type_erasure::any<Concept, T&>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class Concept, class T>
-void* get_pointer(const ::boost::type_erasure::any<Concept, T&>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class Concept, class T>
-const void* get_pointer(::boost::type_erasure::any<Concept, const T&>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class Concept, class T>
-const void* get_pointer(const ::boost::type_erasure::any<Concept, const T&>& arg)
-{
-    return ::boost::type_erasure::detail::access::data(arg).data;
-}
-
-template<class T, class Concept, class Tag>
-bool check_any_cast(const any<Concept, Tag>&, ::boost::mpl::true_)
-{
-    return true;
-}
-
-template<class T, class Concept, class Tag>
-bool check_any_cast(const any<Concept, Tag>& arg, ::boost::mpl::false_)
-{
-    typedef typename ::boost::remove_cv<
-        typename ::boost::remove_reference<Tag>::type
-    >::type tag_type;
-    return ::boost::type_erasure::detail::access::table(arg)
-        .template find<typeid_<tag_type> >()() == typeid(T);
-}
-
-template<class T, class Concept, class Tag>
-bool check_any_cast(const any<Concept, Tag>& arg)
-{
-    return ::boost::type_erasure::detail::check_any_cast<T>(
-        arg, ::boost::is_void<typename ::boost::remove_reference<T>::type>());
-}
-
-}
-
-/**
- * Attempts to extract the object that @c arg holds.
- * If casting to a pointer fails, \any_cast returns
- * a null pointer.  Casting to @c void* always succeeds
- * and returns the address of stored object.
- *
- * \code
- * any<mpl::vector<typeid_<>, copy_constructible<> > > x(1);
- * any_cast<int>(x);      // returns 1
- * any_cast<int&>(x);     // returns a reference to the contents of x
- * any_cast<double>(x);   // throws bad_any_cast
- * any_cast<int*>(&x);    // returns a pointer to the contents of x
- * any_cast<void*>(&x);   // returns a pointer to the contents of x
- * any_cast<double*>(&x); // returns NULL
- * \endcode
- *
- * \pre if @c arg is a pointer, @c T must be a pointer type.
- * \pre @c Concept must contain @ref typeid_ "typeid_<Tag>".
- *
- * \throws bad_any_cast if @c arg doesn't contain
- *         an object of type @c T and we're casting
- *         to a value or reference.
- */
-template<class T, class Concept, class Tag>
-T any_cast(any<Concept, Tag>& arg)
-{
-    if(::boost::type_erasure::detail::check_any_cast<T>(arg)) {
-        return *static_cast<
-            typename ::boost::remove_reference<
-                typename ::boost::add_const<T>::type
-            >::type*
-        >(::boost::type_erasure::detail::get_pointer(arg));
-    } else {
-        BOOST_THROW_EXCEPTION(::boost::type_erasure::bad_any_cast());
-    }
-}
-
-/** \overload */
-template<class T, class Concept, class Tag>
-T any_cast(const any<Concept, Tag>& arg)
-{
-    if(::boost::type_erasure::detail::check_any_cast<T>(arg)) {
-        return *static_cast<
-            typename ::boost::remove_reference<
-                typename ::boost::add_const<T>::type
-            >::type*
-        >(::boost::type_erasure::detail::get_pointer(arg));
-    } else {
-        BOOST_THROW_EXCEPTION(::boost::type_erasure::bad_any_cast());
-    }
-}
-
-/** \overload */
-template<class T, class Concept, class Tag>
-T any_cast(any<Concept, Tag>* arg)
-{
-    BOOST_MPL_ASSERT((::boost::is_pointer<T>));
-    if(::boost::type_erasure::detail::check_any_cast<
-        typename ::boost::remove_pointer<T>::type>(*arg)) {
-        return static_cast<
-            typename ::boost::remove_pointer<T>::type*>(
-                ::boost::type_erasure::detail::get_pointer(*arg));
-    } else {
-        return 0;
-    }
-}
-
-/** \overload */
-template<class T, class Concept, class Tag>
-T any_cast(const any<Concept, Tag>* arg)
-{
-    BOOST_MPL_ASSERT((::boost::is_pointer<T>));
-    if(::boost::type_erasure::detail::check_any_cast<
-        typename ::boost::remove_pointer<T>::type>(*arg)) {
-        return static_cast<
-            typename ::boost::remove_pointer<T>::type*>(
-                ::boost::type_erasure::detail::get_pointer(*arg));
-    } else {
-        return 0;
-    }
-}
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/binding.hpp b/contrib/restricted/boost/boost/type_erasure/binding.hpp
deleted file mode 100644
index c360baad9a..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/binding.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_BINDING_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_BINDING_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/find_if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/pair.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/is_subconcept.hpp>
-#include <boost/type_erasure/detail/adapt_to_vtable.hpp>
-#include <boost/type_erasure/detail/null.hpp>
-#include <boost/type_erasure/detail/rebind_placeholders.hpp>
-#include <boost/type_erasure/detail/vtable.hpp>
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/detail/instantiate.hpp>
-#include <boost/type_erasure/detail/check_map.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-template<class P>
-class dynamic_binding;
-
-namespace detail {
-
-template<class Source, class Dest, class Map>
-struct can_optimize_conversion : ::boost::mpl::and_<
-    ::boost::is_same<Source, Dest>,
-        ::boost::is_same<
-            typename ::boost::mpl::find_if<
-                Map,
-                ::boost::mpl::not_<
-                    ::boost::is_same<
-                        ::boost::mpl::first< ::boost::mpl::_1>,
-                        ::boost::mpl::second< ::boost::mpl::_1>
-                    >
-                >
-            >::type,
-            typename ::boost::mpl::end<Map>::type
-        >
-    >::type
-{};
-
-}
-
-/**
- * Stores the binding of a @c Concept to a set of actual types.
- * @c Concept is interpreted in the same way as with @ref any.
- */
-template<class Concept>
-class binding
-{
-    typedef typename ::boost::type_erasure::detail::normalize_concept<
-        Concept>::type normalized;
-    typedef typename ::boost::mpl::transform<normalized,
-        ::boost::type_erasure::detail::maybe_adapt_to_vtable< ::boost::mpl::_1>
-    >::type actual_concept;
-    typedef typename ::boost::type_erasure::detail::make_vtable<
-        actual_concept>::type table_type;
-    typedef typename ::boost::type_erasure::detail::get_placeholder_normalization_map<
-        Concept
-    >::type placeholder_subs;
-public:
-
-    /**
-     * \pre @ref relaxed must be in @c Concept.
-     *
-     * \throws Nothing.
-     */
-    binding() { BOOST_MPL_ASSERT((::boost::type_erasure::is_relaxed<Concept>)); }
-    
-    /**
-     * \pre @c Map must be an MPL map with an entry for each placeholder
-     *      referred to by @c Concept.
-     *
-     * \throws Nothing.
-     */
-    template<class Map>
-    explicit binding(const Map&)
-      : impl((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            static_binding<Map>()
-        ))
-    {}
-    
-    /**
-     * \pre @c Map must be an MPL map with an entry for each placeholder
-     *      referred to by @c Concept.
-     *
-     * \throws Nothing.
-     */
-    template<class Map>
-    binding(const static_binding<Map>&)
-      : impl((
-            BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map),
-            static_binding<Map>()
-        ))
-    {}
-
-    /**
-     * Converts from another set of bindings.
-     *
-     * \pre Map must be an MPL map with an entry for each placeholder
-     *      referred to by @c Concept.  The mapped type should be the
-     *      corresponding placeholder in Concept2.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Map>
-    binding(const binding<Concept2>& other, const Map&
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::enable_if<
-            ::boost::mpl::and_<
-                ::boost::type_erasure::detail::check_map<Concept, Map>,
-                ::boost::type_erasure::is_subconcept<Concept, Concept2, Map>
-            >
-        >::type* = 0
-#endif
-        )
-      : impl(
-            other,
-            static_binding<Map>(),
-            ::boost::type_erasure::detail::can_optimize_conversion<Concept2, Concept, Map>()
-        )
-    {}
-
-    /**
-     * Converts from another set of bindings.
-     *
-     * \pre Map must be an MPL map with an entry for each placeholder
-     *      referred to by @c Concept.  The mapped type should be the
-     *      corresponding placeholder in Concept2.
-     *
-     * \throws std::bad_alloc
-     */
-    template<class Concept2, class Map>
-    binding(const binding<Concept2>& other, const static_binding<Map>&
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-        , typename ::boost::enable_if<
-            ::boost::mpl::and_<
-                ::boost::type_erasure::detail::check_map<Concept, Map>,
-                ::boost::type_erasure::is_subconcept<Concept, Concept2, Map>
-            >
-        >::type* = 0
-#endif
-        )
-      : impl(
-            other,
-            static_binding<Map>(),
-            ::boost::type_erasure::detail::can_optimize_conversion<Concept2, Concept, Map>()
-        )
-    {}
-
-    /**
-     * Converts from another set of bindings.
-     *
-     * \pre Map must be an MPL map with an entry for each placeholder
-     *      referred to by @c Concept.  The mapped type should be the
-     *      corresponding placeholder in Concept2.
-     *
-     * \throws std::bad_alloc
-     * \throws std::bad_any_cast
-     */
-    template<class Placeholders, class Map>
-    binding(const dynamic_binding<Placeholders>& other, const static_binding<Map>&)
-      : impl(
-            other,
-            static_binding<Map>()
-        )
-    {}
-
-    /**
-     * \return true iff the sets of types that the placeholders
-     *         bind to are the same for both arguments.
-     *
-     * \throws Nothing.
-     */
-    friend bool operator==(const binding& lhs, const binding& rhs)
-    { return *lhs.impl.table == *rhs.impl.table; }
-    
-    /**
-     * \return true iff the arguments do not map to identical
-     *         sets of types.
-     *
-     * \throws Nothing.
-     */
-    friend bool operator!=(const binding& lhs, const binding& rhs)
-    { return !(lhs == rhs); }
-
-    /** INTERNAL ONLY */
-    template<class T>
-    typename T::type find() const { return impl.table->lookup((T*)0); }
-private:
-    template<class C2>
-    friend class binding;
-    template<class P>
-    friend class dynamic_binding;
-    /** INTERNAL ONLY */
-    struct impl_type
-    {
-        impl_type() {
-            table = &::boost::type_erasure::detail::make_vtable_init<
-                typename ::boost::mpl::transform<
-                    actual_concept,
-                    ::boost::type_erasure::detail::get_null_vtable_entry<
-                        ::boost::mpl::_1
-                    >
-                >::type,
-                table_type
-            >::type::value;
-        }
-        template<class Map>
-        impl_type(const static_binding<Map>&)
-        {
-            table = &::boost::type_erasure::detail::make_vtable_init<
-                typename ::boost::mpl::transform<
-                    actual_concept,
-                    ::boost::type_erasure::detail::rebind_placeholders<
-                        ::boost::mpl::_1,
-                        typename ::boost::type_erasure::detail::add_deductions<
-                            Map,
-                            placeholder_subs
-                        >::type
-                    >
-                >::type,
-                table_type
-            >::type::value;
-        }
-        template<class Concept2, class Map>
-        impl_type(const binding<Concept2>& other, const static_binding<Map>&, boost::mpl::false_)
-          : manager(new table_type)
-        {
-            manager->template convert_from<
-                typename ::boost::type_erasure::detail::convert_deductions<
-                    Map,
-                    placeholder_subs,
-                    typename binding<Concept2>::placeholder_subs
-                >::type
-            >(*other.impl.table);
-            table = manager.get();
-        }
-        template<class PlaceholderList, class Map>
-        impl_type(const dynamic_binding<PlaceholderList>& other, const static_binding<Map>&)
-          : manager(new table_type)
-        {
-            manager->template convert_from<
-                // FIXME: What do we need to do with deduced placeholder in other
-                typename ::boost::type_erasure::detail::add_deductions<
-                    Map,
-                    placeholder_subs
-                >::type
-            >(other.impl);
-            table = manager.get();
-        }
-        template<class Concept2, class Map>
-        impl_type(const binding<Concept2>& other, const static_binding<Map>&, boost::mpl::true_)
-          : table(other.impl.table),
-            manager(other.impl.manager)
-        {}
-        const table_type* table;
-        ::boost::shared_ptr<table_type> manager;
-    } impl;
-};
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/binding_of.hpp b/contrib/restricted/boost/boost/type_erasure/binding_of.hpp
deleted file mode 100644
index 2229fdeb84..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/binding_of.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_BINDING_OF_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_BINDING_OF_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/access.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/binding.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * \return The type bindings of an @ref any.
- *
- * \throws Nothing.
- */
-template<class Concept, class T>
-const binding<Concept>& binding_of(const any<Concept, T>& arg)
-{
-    return ::boost::type_erasure::detail::access::table(arg);
-}
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/callable.hpp b/contrib/restricted/boost/boost/type_erasure/callable.hpp
deleted file mode 100644
index 0556f1529d..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/callable.hpp
+++ /dev/null
@@ -1,389 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#ifndef BOOST_TYPE_ERASURE_CALLABLE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_CALLABLE_HPP_INCLUDED
-
-#include <boost/detail/workaround.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/push_back.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/dec.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/type_erasure/config.hpp>
-#include <boost/type_erasure/call.hpp>
-#include <boost/type_erasure/concept_interface.hpp>
-#include <boost/type_erasure/rebind_any.hpp>
-#include <boost/type_erasure/param.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-template<class Sig, class F = _self>
-struct callable;
-
-namespace detail {
-
-template<class Sig>
-struct result_of_callable;
-
-}
-
-#if defined(BOOST_TYPE_ERASURE_DOXYGEN)
-
-/**
- * The @ref callable concept allows an @ref any to hold function objects.
- * @c Sig is interpreted in the same way as for Boost.Function, except
- * that the arguments and return type are allowed to be placeholders.
- * @c F must be a @ref placeholder.
- *
- * Multiple instances of @ref callable can be used
- * simultaneously.  Overload resolution works normally.
- * Note that unlike Boost.Function, @ref callable
- * does not provide result_type.  It does, however,
- * support @c boost::result_of.
- */
-template<class Sig, class F = _self>
-struct callable
-{
-    /**
-     * @c R is the result type of @c Sig and @c T is the argument
-     * types of @c Sig.
-     */
-    static R apply(F& f, T... arg);
-};
-
-#elif !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
-
-template<class R, class... T, class F>
-struct callable<R(T...), F>
-{
-    static R apply(F& f, T... arg)
-    {
-        return f(std::forward<T>(arg)...);
-    }
-};
-
-template<class... T, class F>
-struct callable<void(T...), F>
-{
-    static void apply(F& f, T... arg)
-    {
-        f(std::forward<T>(arg)...);
-    }
-};
-
-template<class R, class F, class Base, class Enable, class... T>
-struct concept_interface<callable<R(T...), F>, Base, F, Enable>
-  : Base
-{
-    template<class Sig>
-    struct result :
-        ::boost::type_erasure::detail::result_of_callable<Sig>
-    {};
-    typedef void _boost_type_erasure_is_callable;
-    typedef ::boost::mpl::vector<R> _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[1];
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        typename ::boost::type_erasure::as_param<Base, T>::type...);
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(typename ::boost::type_erasure::as_param<Base, T>::type... arg)
-    {
-        return ::boost::type_erasure::call(callable<R(T...), F>(), *this,
-            ::std::forward<typename ::boost::type_erasure::as_param<Base, T>::type>(arg)...);
-    }
-};
-
-template<class R, class F, class Base, class Enable, class... T>
-struct concept_interface<callable<R(T...), const F>, Base, F, Enable>
-  : Base
-{
-    template<class Sig>
-    struct result :
-        ::boost::type_erasure::detail::result_of_callable<Sig>
-    {};
-    typedef void _boost_type_erasure_is_callable;
-    typedef ::boost::mpl::vector<R> _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[1];
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        typename ::boost::type_erasure::as_param<Base, T>::type...) const;
-    typename ::boost::type_erasure::rebind_any<Base, R>::type operator()(
-        typename ::boost::type_erasure::as_param<Base, T>::type... arg) const
-    {
-        return ::boost::type_erasure::call(callable<R(T...), const F>(), *this,
-            ::std::forward<typename ::boost::type_erasure::as_param<Base, T>::type>(arg)...);
-    }
-};
-
-template<class R, class F, class Base, class... T>
-struct concept_interface<
-    callable<R(T...), F>,
-    Base,
-    F,
-    typename Base::_boost_type_erasure_is_callable
->
-  : Base
-{
-    typedef typename ::boost::mpl::push_back<
-        typename Base::_boost_type_erasure_callable_results,
-        R
-    >::type _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[
-        ::boost::mpl::size<_boost_type_erasure_callable_results>::value];
-    using Base::_boost_type_erasure_deduce_callable;
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        typename ::boost::type_erasure::as_param<Base, T>::type...);
-    using Base::operator();
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(typename ::boost::type_erasure::as_param<Base, T>::type... arg)
-    {
-        return ::boost::type_erasure::call(callable<R(T...), F>(), *this,
-            ::std::forward<typename ::boost::type_erasure::as_param<Base, T>::type>(arg)...);
-    }
-};
-
-template<class R, class F, class Base, class... T>
-struct concept_interface<
-    callable<R(T...), const F>,
-    Base,
-    F,
-    typename Base::_boost_type_erasure_is_callable
->
-  : Base
-{
-    typedef typename ::boost::mpl::push_back<
-        typename Base::_boost_type_erasure_callable_results,
-        R
-    >::type _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[
-        ::boost::mpl::size<_boost_type_erasure_callable_results>::value];
-    using Base::_boost_type_erasure_deduce_callable;
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        typename ::boost::type_erasure::as_param<Base, T>::type...) const;
-    using Base::operator();
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(typename ::boost::type_erasure::as_param<Base, T>::type... arg) const
-    {
-        return ::boost::type_erasure::call(callable<R(T...), const F>(), *this,
-            ::std::forward<typename ::boost::type_erasure::as_param<Base, T>::type>(arg)...);
-    }
-};
-
-namespace detail {
-
-template<class This, class... T>
-struct result_of_callable<This(T...)>
-{
-    typedef typename ::boost::mpl::at_c<
-        typename This::_boost_type_erasure_callable_results,
-        sizeof(::boost::declval<This>().
-            _boost_type_erasure_deduce_callable(::boost::declval<T>()...)) - 1
-    >::type type;
-};
-
-}
-
-#else
-
-/** INTERNAL ONLY */
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/callable.hpp>
-/** INTERNAL ONLY */
-#define BOOST_PP_ITERATION_LIMITS (0, BOOST_PP_DEC(BOOST_TYPE_ERASURE_MAX_ARITY))
-#include BOOST_PP_ITERATE()
-
-#endif
-
-}
-}
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-#define BOOST_TYPE_ERASURE_DECLVAL(z, n, data) ::boost::declval<BOOST_PP_CAT(T, n)>()
-
-#define BOOST_TYPE_ERASURE_REBIND(z, n, data)\
-    typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(T, n)>::type BOOST_PP_CAT(arg, n)
-
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-#define BOOST_TYPE_ERASURE_FORWARD(z, n, data) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n)
-#define BOOST_TYPE_ERASURE_FORWARD_REBIND(z, n, data) BOOST_PP_CAT(arg, n)
-#else
-#define BOOST_TYPE_ERASURE_FORWARD(z, n, data) ::std::forward<BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n)>(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n))
-#define BOOST_TYPE_ERASURE_FORWARD_REBIND(z, n, data) ::std::forward<typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(T, n)>::type>(BOOST_PP_CAT(arg, n))
-#endif
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class F>
-struct callable<R(BOOST_PP_ENUM_PARAMS(N, T)), F>
-{
-    static R apply(F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, T, arg))
-    {
-        return f(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_FORWARD, (T, arg)));
-    }
-};
-
-template<BOOST_PP_ENUM_PARAMS(N, class T) BOOST_PP_COMMA_IF(N) class F>
-struct callable<void(BOOST_PP_ENUM_PARAMS(N, T)), F>
-{
-    static void apply(F& f BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, T, arg))
-    {
-        f(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_FORWARD, (T, arg)));
-    }
-};
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class F, class Base, class Enable>
-struct concept_interface<
-    callable<R(BOOST_PP_ENUM_PARAMS(N, T)), F>,
-    Base,
-    F,
-    Enable
->
-  : Base
-{
-    template<class Sig>
-    struct result :
-        ::boost::type_erasure::detail::result_of_callable<Sig>
-    {};
-    typedef void _boost_type_erasure_is_callable;
-    typedef ::boost::mpl::vector<R> _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[1];
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~));
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~))
-    {
-        return ::boost::type_erasure::call(
-            callable<R(BOOST_PP_ENUM_PARAMS(N, T)), F>(),
-            *this BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND, ~));
-    }
-};
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class F, class Base, class Enable>
-struct concept_interface<
-    callable<R(BOOST_PP_ENUM_PARAMS(N, T)), const F>,
-    Base,
-    F,
-    Enable
->
-  : Base
-{
-    template<class Sig>
-    struct result :
-        ::boost::type_erasure::detail::result_of_callable<Sig>
-    {};
-    typedef void _boost_type_erasure_is_callable;
-    typedef ::boost::mpl::vector<R> _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[1];
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~)) const;
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~)) const
-    {
-        return ::boost::type_erasure::call(
-            callable<R(BOOST_PP_ENUM_PARAMS(N, T)), const F>(),
-            *this BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND, ~));
-    }
-};
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class F, class Base>
-struct concept_interface<
-    callable<R(BOOST_PP_ENUM_PARAMS(N, T)), F>,
-    Base,
-    F,
-    typename Base::_boost_type_erasure_is_callable
->
-  : Base
-{
-    typedef typename ::boost::mpl::push_back<
-        typename Base::_boost_type_erasure_callable_results,
-        R
-    >::type _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[
-        ::boost::mpl::size<_boost_type_erasure_callable_results>::value];
-    using Base::_boost_type_erasure_deduce_callable;
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~));
-    using Base::operator();
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~))
-    {
-        return ::boost::type_erasure::call(
-            callable<R(BOOST_PP_ENUM_PARAMS(N, T)), F>(),
-            *this BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND, ~));
-    }
-};
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class F, class Base>
-struct concept_interface<
-    callable<R(BOOST_PP_ENUM_PARAMS(N, T)), const F>,
-    Base,
-    F,
-    typename Base::_boost_type_erasure_is_callable
->
-  : Base
-{
-    typedef typename ::boost::mpl::push_back<
-        typename Base::_boost_type_erasure_callable_results,
-        R
-    >::type _boost_type_erasure_callable_results;
-    typedef char (&_boost_type_erasure_callable_size)[
-        ::boost::mpl::size<_boost_type_erasure_callable_results>::value];
-    using Base::_boost_type_erasure_deduce_callable;
-    _boost_type_erasure_callable_size
-    _boost_type_erasure_deduce_callable(
-        BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~)) const;
-    using Base::operator();
-    typename ::boost::type_erasure::rebind_any<Base, R>::type
-    operator()(BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_REBIND, ~)) const
-    {
-        return ::boost::type_erasure::call(
-            callable<R(BOOST_PP_ENUM_PARAMS(N, T)), const F>(),
-            *this BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND, ~));
-    }
-};
-
-namespace detail {
-
-template<class This BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-struct result_of_callable<This(BOOST_PP_ENUM_PARAMS(N, T))>
-{
-    typedef typename ::boost::mpl::at_c<
-        typename This::_boost_type_erasure_callable_results,
-        sizeof(::boost::declval<This>().
-            _boost_type_erasure_deduce_callable(
-                BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_DECLVAL, ~))) - 1
-    >::type type;
-};
-
-}
-
-#undef BOOST_TYPE_ERASURE_DECLVAL
-#undef BOOST_TYPE_ERASURE_REBIND
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/derived.hpp b/contrib/restricted/boost/boost/type_erasure/derived.hpp
deleted file mode 100644
index 844d9c2072..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/derived.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DERIVED_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DERIVED_HPP_INCLUDED
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * A metafunction which returns the full @ref any type,
- * when given any of its base classes.  This is primarily
- * intended to be used when implementing @ref concept_interface.
- *
- * \see rebind_any, as_param
- */
-template<class T>
-struct derived
-{
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-    typedef detail::unspecified type;
-#else
-    typedef typename T::_boost_type_erasure_derived_type type;
-#endif
-};
-
-#ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES
-
-template<class T>
-using derived_t = typename T::_boost_type_erasure_derived_type;
-
-#endif
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/const.hpp b/contrib/restricted/boost/boost/type_erasure/detail/const.hpp
deleted file mode 100644
index fc97d4fc30..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/const.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_CONST_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_CONST_HPP_INCLUDED
-
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/type_traits/is_reference.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_erasure/placeholder_of.hpp>
-#include <boost/type_erasure/derived.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-template<class T>
-struct is_non_const_ref : boost::mpl::false_ {};
-template<class T>
-struct is_non_const_ref<T&> : boost::mpl::true_ {};
-template<class T>
-struct is_non_const_ref<const T&> : boost::mpl::false_ {};
-
-template<class Placeholder, class Base>
-struct should_be_const :
-    ::boost::mpl::or_<
-        ::boost::is_const<Placeholder>,
-        ::boost::type_erasure::detail::is_non_const_ref<
-            typename ::boost::type_erasure::placeholder_of<Base>::type
-        >
-    >
-{};
-
-template<class Placeholder, class Base>
-struct should_be_non_const :
-    ::boost::mpl::and_<
-        ::boost::mpl::not_< ::boost::is_const<Placeholder> >,
-        ::boost::mpl::not_<
-            ::boost::is_reference<
-                typename ::boost::type_erasure::placeholder_of<Base>::type
-            >
-        >
-    >
-{};
-
-template<class Base>
-struct non_const_this_param
-{
-    typedef typename ::boost::type_erasure::placeholder_of<Base>::type placeholder;
-    typedef typename ::boost::type_erasure::derived<Base>::type plain_type;
-    typedef typename ::boost::mpl::if_<
-        ::boost::is_same<
-            placeholder,
-            typename ::boost::remove_cv<
-                typename ::boost::remove_reference<placeholder>::type
-            >::type&
-        >,
-        const plain_type,
-        plain_type
-    >::type type;
-};
-
-template<class T>
-struct uncallable {};
-
-template<class Placeholder, class Base>
-struct maybe_const_this_param
-{
-    typedef typename ::boost::type_erasure::derived<Base>::type plain_type;
-    typedef typename ::boost::remove_reference<Placeholder>::type plain_placeholder;
-    typedef typename ::boost::mpl::if_< ::boost::is_reference<Placeholder>,
-        typename ::boost::mpl::if_<
-            ::boost::type_erasure::detail::should_be_non_const<plain_placeholder, Base>,
-            plain_type&,
-            typename ::boost::mpl::if_<
-                ::boost::type_erasure::detail::should_be_const<plain_placeholder, Base>,
-                const plain_type&,
-                uncallable<plain_type>
-            >::type
-        >::type,
-        plain_type
-    >::type type;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-template<class Placeholder, class Base>
-struct maybe_const_this_param<Placeholder&&, Base>
-{
-    typedef typename ::boost::type_erasure::derived<Base>::type plain_type;
-    typedef typename ::boost::remove_reference<Placeholder>::type plain_placeholder;
-    typedef typename ::boost::type_erasure::placeholder_of<plain_type>::type self_placeholder;
-    typedef typename ::boost::mpl::if_< ::boost::is_lvalue_reference<self_placeholder>,
-        ::boost::type_erasure::detail::uncallable<plain_type>,
-        typename ::boost::mpl::if_< ::boost::is_rvalue_reference<self_placeholder>,
-            const plain_type&,
-            plain_type&&
-        >::type
-    >::type type;
-};
-
-#endif
-
-}
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/construct.hpp b/contrib/restricted/boost/boost/type_erasure/detail/construct.hpp
deleted file mode 100644
index 563bbeeb90..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/construct.hpp
+++ /dev/null
@@ -1,211 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_CONSTRUCT_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_CONSTRUCT_HPP_INCLUDED
-
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/detail/construct.hpp>
-#define BOOST_PP_ITERATION_LIMITS (1, BOOST_TYPE_ERASURE_MAX_ARITY)
-#include BOOST_PP_ITERATE()
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-#define BOOST_TYPE_ERASURE_FORWARD_I(z, n, data) ::std::forward<BOOST_PP_CAT(U, n)>(BOOST_PP_CAT(u, n))
-#define BOOST_TYPE_ERASURE_FORWARD(n) BOOST_PP_ENUM(n, BOOST_TYPE_ERASURE_FORWARD_I, ~)
-
-#if N > 1
-
-    template<
-        class R
-        BOOST_PP_ENUM_TRAILING_PARAMS(N, class A)
-        BOOST_PP_ENUM_TRAILING_PARAMS(N, class U)
-    >
-    const table_type& _boost_type_erasure_extract_table(
-        ::boost::type_erasure::constructible<R(BOOST_PP_ENUM_PARAMS(N, A))>*
-        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
-    {
-        return *::boost::type_erasure::detail::BOOST_PP_CAT(extract_table, N)(
-            (R(*)(BOOST_PP_ENUM_PARAMS(N, A)))0,
-            BOOST_PP_ENUM_PARAMS(N, u));
-    }
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(BOOST_PP_ENUM_BINARY_PARAMS(N, U, &&u))
-      : table(
-            _boost_type_erasure_extract_table(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        ),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
-            ), BOOST_TYPE_ERASURE_FORWARD(N))
-        )
-    {}
-
-#endif
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(const binding<Concept>& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &&u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
-                )
-                BOOST_PP_COMMA_IF(N)
-                BOOST_TYPE_ERASURE_FORWARD(N)
-            )
-        )
-    {}
-
-    // disambiguate
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(binding<Concept>& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &&u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
-                )
-                BOOST_PP_COMMA_IF(N)
-                BOOST_TYPE_ERASURE_FORWARD(N)
-            )
-        )
-    {}
-
-    // disambiguate
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(binding<Concept>&& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &&u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
-                )
-                BOOST_PP_COMMA_IF(N)
-                BOOST_TYPE_ERASURE_FORWARD(N)
-            )
-        )
-    {}
-
-#undef BOOST_TYPE_ERASURE_FORWARD
-#undef BOOST_TYPE_ERASURE_FORWARD_I
-
-#else
-
-#if N > 1
-
-    template<
-        class R
-        BOOST_PP_ENUM_TRAILING_PARAMS(N, class A)
-        BOOST_PP_ENUM_TRAILING_PARAMS(N, class U)
-    >
-    const table_type& _boost_type_erasure_extract_table(
-        ::boost::type_erasure::constructible<R(BOOST_PP_ENUM_PARAMS(N, A))>*
-        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
-    {
-        return *::boost::type_erasure::detail::BOOST_PP_CAT(extract_table, N)(
-            (R(*)(BOOST_PP_ENUM_PARAMS(N, A)))0,
-            BOOST_PP_ENUM_PARAMS(N, u));
-    }
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(BOOST_PP_ENUM_BINARY_PARAMS(N, const U, &u))
-      : table(
-            _boost_type_erasure_extract_table(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        ),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-            ), BOOST_PP_ENUM_PARAMS(N, u))
-        )
-    {}
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(BOOST_PP_ENUM_BINARY_PARAMS(N, U, &u))
-      : table(
-            _boost_type_erasure_extract_table(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        ),
-        data(::boost::type_erasure::call(
-            ::boost::type_erasure::detail::make(
-                false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-            ), BOOST_PP_ENUM_PARAMS(N, u))
-        )
-    {}
-
-#endif
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(const binding<Concept>& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, const U, &u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-                )
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        )
-    {}
-
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(const binding<Concept>& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-                )
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        )
-    {}
-
-    // disambiguate
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    any(binding<Concept>& binding_arg BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
-      : table(binding_arg),
-        data(
-            ::boost::type_erasure::call(
-                binding_arg,
-                ::boost::type_erasure::detail::make(
-                    false? this->_boost_type_erasure_deduce_constructor(BOOST_PP_ENUM_PARAMS(N, u)) : 0
-                )
-                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-            )
-        )
-    {}
-
-#endif
-
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/dynamic_vtable.hpp b/contrib/restricted/boost/boost/type_erasure/detail/dynamic_vtable.hpp
deleted file mode 100644
index 959f2f3a32..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/dynamic_vtable.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2015 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_DYNAMIC_VTABLE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_DYNAMIC_VTABLE_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/get_placeholders.hpp>
-#include <boost/type_erasure/detail/rebind_placeholders.hpp>
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/detail/adapt_to_vtable.hpp>
-#include <boost/type_erasure/detail/vtable.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/register_binding.hpp>
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/set.hpp>
-#include <boost/mpl/for_each.hpp>
-#include <boost/mpl/index_of.hpp>
-#include <typeinfo>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-
-template<class P>
-struct dynamic_binding_impl {
-    const std::type_info * type;
-    dynamic_binding_impl() = default;
-    constexpr dynamic_binding_impl(const std::type_info * t) : type(t) {}
-};
-
-template<class T>
-struct dynamic_binding_element {
-    typedef const std::type_info * type;
-};
-
-template<class Table>
-struct append_to_key {
-    template<class P>
-    void operator()(P) {
-        key->push_back(static_cast<const dynamic_binding_impl<P>*>(table)->type);
-    }
-    const Table * table;
-    key_type * key;
-};
-
-template<class... P>
-struct dynamic_vtable : dynamic_binding_impl<P>... {
-    dynamic_vtable() = default;
-    constexpr dynamic_vtable(typename dynamic_binding_element<P>::type ...t) : dynamic_binding_impl<P>(t)... {}
-    template<class F>
-    typename F::type lookup(F*) const {
-        key_type key;
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-        typedef typename ::boost::type_erasure::detail::get_placeholders<F, ::boost::mpl::set0<> >::type placeholders;
-#else
-        typedef typename ::boost::type_erasure::detail::get_placeholders<F, ::boost::mp11::mp_list<> >::type placeholders;
-#endif
-        typedef typename ::boost::mpl::fold<
-            placeholders,
-            ::boost::mpl::map0<>,
-            ::boost::type_erasure::detail::counting_map_appender
-        >::type placeholder_map;
-        key.push_back(&typeid(typename ::boost::type_erasure::detail::rebind_placeholders<F, placeholder_map>::type));
-        ::boost::mpl::for_each<placeholders>(append_to_key<dynamic_vtable>{this, &key});
-        return reinterpret_cast<typename F::type>(lookup_function_impl(key));
-    }
-    template<class Bindings>
-    void init() {
-        *this = dynamic_vtable(&typeid(typename boost::mpl::at<Bindings, P>::type)...);
-    }
-    template<class Bindings, class Src>
-    void convert_from(const Src& src) {
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-        *this = dynamic_vtable(
-            (&src.lookup((::boost::type_erasure::typeid_<typename ::boost::mpl::at<Bindings, P>::type>*)0)())...);
-#else
-        *this = dynamic_vtable(
-            (&src.lookup((::boost::type_erasure::typeid_< ::boost::mp11::mp_second< ::boost::mp11::mp_map_find<Bindings, P> > >*)0)())...);
-#endif
-    }
-};
-
-template<class L>
-struct make_dynamic_vtable_impl;
-
-template<class... P>
-struct make_dynamic_vtable_impl<stored_arg_pack<P...> >
-{
-    typedef dynamic_vtable<P...> type;
-};
-
-template<class PlaceholderList>
-struct make_dynamic_vtable
-    : make_dynamic_vtable_impl<typename make_arg_pack<PlaceholderList>::type>
-{};
-
-#else
-
-template<class Bindings>
-struct dynamic_vtable_initializer
-{
-    dynamic_vtable_initializer(const std::type_info**& ptr) : types(&ptr) {}
-    template<class P>
-    void operator()(P)
-    {
-        *(*types)++ = &typeid(typename ::boost::mpl::at<Bindings, P>::type);
-    }
-    const ::std::type_info*** types;
-};
-
-template<class Placeholders>
-struct dynamic_vtable
-{
-    const ::std::type_info * types[(::boost::mpl::size<Placeholders>::value)];
-    struct append_to_key
-    {
-        append_to_key(const std::type_info * const * t, key_type* k) : types(t), key(k) {}
-        template<class P>
-        void operator()(P)
-        {
-            key->push_back(types[(::boost::mpl::index_of<Placeholders, P>::type::value)]);
-        }
-        const std::type_info * const * types;
-        key_type * key;
-    };
-    template<class F>
-    typename F::type lookup(F*) const {
-        key_type key;
-        typedef typename ::boost::type_erasure::detail::get_placeholders<F, ::boost::mpl::set0<> >::type placeholders;
-        typedef typename ::boost::mpl::fold<
-            placeholders,
-            ::boost::mpl::map0<>,
-            ::boost::type_erasure::detail::counting_map_appender
-        >::type placeholder_map;
-        key.push_back(&typeid(typename ::boost::type_erasure::detail::rebind_placeholders<F, placeholder_map>::type));
-        ::boost::mpl::for_each<placeholders>(append_to_key(types, &key));
-        return reinterpret_cast<typename F::type>(lookup_function_impl(key));
-    }
-    template<class Bindings>
-    void init()
-    {
-        const std::type_info* ptr = types;
-        ::boost::mpl::for_each<Placeholders>(dynamic_vtable_initializer<Bindings>(ptr));
-    }
-    template<class Bindings, class Src>
-    struct converter
-    {
-        converter(const std::type_info**& t, const Src& s) : types(&t), src(&s) {}
-        template<class P>
-        void operator()(P)
-        {
-            *(*types)++ = &src->lookup((::boost::type_erasure::typeid_<typename ::boost::mpl::at<Bindings, P>::type>*)0)();
-        }
-        const std::type_info*** types;
-        const Src * src;
-    };
-    template<class Bindings, class Src>
-    void convert_from(const Src& src) {
-        const ::std::type_info** ptr = types;
-        ::boost::mpl::for_each<Placeholders>(converter<Bindings, Src>(ptr, src));
-    }
-};
-
-template<class Placeholders>
-struct make_dynamic_vtable
-{
-    typedef dynamic_vtable<Placeholders> type;
-};
-
-#endif
-
-}
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/instantiate.hpp b/contrib/restricted/boost/boost/type_erasure/detail/instantiate.hpp
deleted file mode 100644
index eef39955c0..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/instantiate.hpp
+++ /dev/null
@@ -1,169 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_INSTANTIATE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_INSTANTIATE_HPP_INCLUDED
-
-#include <boost/mpl/transform.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/detail/rebind_placeholders.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-#ifdef BOOST_TYPE_ERASURE_USE_MP11
-
-template<class L>
-struct make_instantiate_concept_impl;
-
-template<class T, T t>
-struct instantiate_concept;
-
-template<class T>
-using instantiate_concept_impl = instantiate_concept<decltype(&T::apply), &T::apply>;
-
-template<class... T>
-struct make_instantiate_concept_impl< ::boost::mp11::mp_list<T...> >
-{
-    template<template<class> class F>
-    using apply = void(F<T>...);
-};
-
-template<class Map>
-struct instantiate_concept_rebind_f
-{
-    template<class T>
-    using apply =
-        typename ::boost::type_erasure::detail::rebind_placeholders<
-            T,
-            Map
-        >::type;
-};
-
-template<class Concept, class Map>
-using make_instantiate_concept =
-    ::boost::type_erasure::detail::make_instantiate_concept_impl<
-        ::boost::mp11::mp_transform<
-            ::boost::type_erasure::detail::instantiate_concept_rebind_f<
-                typename ::boost::type_erasure::detail::add_deductions<
-                    ::boost::type_erasure::detail::make_mp_list<Map>,
-                    typename ::boost::type_erasure::detail::get_placeholder_normalization_map<
-                        Concept
-                    >::type
-                >::type
-            >::template apply,
-            ::boost::type_erasure::detail::normalize_concept_t<Concept>
-        >
-    >;
-
-#define BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map)                                        \
-    ((void)(typename ::boost::type_erasure::detail::make_instantiate_concept<Concept, Map>  \
-        ::template apply< ::boost::type_erasure::detail::instantiate_concept_impl>*)0)
-
-#define BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, P0, T0)                        \
-    ((void)(typename ::boost::type_erasure::detail::make_instantiate_concept<   \
-        Concept, ::boost::mpl::map1< ::boost::mpl::pair<P0, T0> > >             \
-        ::template apply< ::boost::type_erasure::detail::instantiate_concept_impl>*)0)
-
-#else
-
-template<int N>
-struct make_instantiate_concept_impl;
-
-template<class Concept>
-struct make_instantiate_concept {
-    typedef typename ::boost::type_erasure::detail::normalize_concept<
-        Concept>::type normalized;
-    typedef typename ::boost::type_erasure::detail::make_instantiate_concept_impl<
-        (::boost::mpl::size<normalized>::value)
-    >::type type;
-};
-
-#define BOOST_TYPE_ERASURE_INSTANTIATE(Concept, Map)            \
-    (::boost::type_erasure::detail::make_instantiate_concept<   \
-        Concept                                                 \
-    >::type::apply((Concept*)0, (Map*)0))
-
-#define BOOST_TYPE_ERASURE_INSTANTIATE1(Concept, P0, T0)        \
-    (::boost::type_erasure::detail::make_instantiate_concept<   \
-        Concept                                                 \
-    >::type::apply(                                             \
-        (Concept*)0,                                            \
-        (::boost::mpl::map1< ::boost::mpl::pair<P0, T0> >*)0))
-
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/detail/instantiate.hpp>
-#define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPE_ERASURE_MAX_FUNCTIONS)
-#include BOOST_PP_ITERATE()
-
-#endif
-
-}
-}
-}
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-
-#define BOOST_TYPE_ERASURE_INSTANTIATE_IMPL(z, n, data)\
-    (void)&::boost::mpl::at_c<data, n>::type::apply;
-
-struct BOOST_PP_CAT(instantiate_concept, N) {
-    template<class Concept, class Map>
-    static void apply(Concept *, Map *) {
-#if N > 0
-        typedef typename ::boost::type_erasure::detail::normalize_concept<
-            Concept>::type normalized;
-        typedef typename ::boost::type_erasure::detail::get_placeholder_normalization_map<
-            Concept
-        >::type placeholder_subs;
-
-        typedef typename ::boost::mpl::transform<
-            normalized,
-            ::boost::type_erasure::detail::rebind_placeholders<
-                ::boost::mpl::_1,
-                typename ::boost::type_erasure::detail::add_deductions<
-                    Map,
-                    placeholder_subs
-                >::type
-            >
-        >::type concept_sequence;
-#endif
-        BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_INSTANTIATE_IMPL, concept_sequence)
-    }
-};
-
-template<>
-struct make_instantiate_concept_impl<N>
-{
-    typedef ::boost::type_erasure::detail::BOOST_PP_CAT(instantiate_concept, N) type;
-};
-
-#undef BOOST_TYPE_ERASURE_INSTANTIATE_IMPL
-
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/macro.hpp b/contrib/restricted/boost/boost/type_erasure/detail/macro.hpp
deleted file mode 100644
index badd853195..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/macro.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_MACRO_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_MACRO_HPP_INCLUDED
-
-#include <boost/preprocessor/dec.hpp>
-#include <boost/preprocessor/if.hpp>
-#include <boost/preprocessor/comparison/not_equal.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/pop_back.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/tuple/eat.hpp>
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_OPEN_NAMESPACE_F(z, data, x) \
-    namespace x {
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_OPEN_NAMEPACE_I(seq)\
-    BOOST_PP_SEQ_FOR_EACH(BOOST_TYPE_ERASURE_OPEN_NAMESPACE_F, ~, BOOST_PP_SEQ_POP_BACK(seq))
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_OPEN_NAMESPACE(seq)\
-    BOOST_PP_IF(BOOST_PP_NOT_EQUAL(BOOST_PP_SEQ_SIZE(seq), 1), BOOST_TYPE_ERASURE_OPEN_NAMEPACE_I, BOOST_PP_TUPLE_EAT(1))(seq)
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(seq) \
-    BOOST_PP_REPEAT(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)), } BOOST_PP_TUPLE_EAT(3), ~)
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_QUALIFIED_NAME_F(z, data, x)\
-    ::x
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq) \
-    BOOST_PP_SEQ_FOR_EACH(BOOST_TYPE_ERASURE_QUALIFIED_NAME_F, ~, seq)
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/member11.hpp b/contrib/restricted/boost/boost/type_erasure/detail/member11.hpp
deleted file mode 100644
index 7bc8eee6a9..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/member11.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2018 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_MEMBER11_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_MEMBER11_HPP_INCLUDED
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_DECLTYPE) && \
-    !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
-
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/punctuation/is_begin_parens.hpp>
-#include <boost/vmd/is_empty.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_erasure/detail/const.hpp>
-#include <boost/type_erasure/detail/macro.hpp>
-#include <boost/type_erasure/rebind_any.hpp>
-#include <boost/type_erasure/param.hpp>
-#include <boost/type_erasure/is_placeholder.hpp>
-#include <boost/type_erasure/call.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-template<class P, template<class ...> class interface, class Sig, class Concept, class Base, class ID>
-using choose_member_interface = typename ::boost::mpl::if_c< ::boost::is_reference<P>::value,
-    typename ::boost::mpl::if_c< ::boost::type_erasure::detail::is_non_const_ref<P>::value,
-        interface<Sig, Concept, Base, const ID>,
-        Base
-    >::type,
-    interface<Sig, Concept, Base, ID>
->::type;
-
-
-struct dummy {};
-
-template<class Sig>
-struct choose_member_impl;
-
-template<class R, class C, class... T>
-struct choose_member_impl<R (C::*)(T...) const>
-{
-    template<class P, template<class> class M, template<class,class> class S> 
-    using apply = ::boost::mpl::vector1<S<R(T...), const P> >;
-};
-
-template<class R, class C, class... T>
-struct choose_member_impl<R (C::*)(T...)>
-{
-    template<class P, template<class> class M, template<class,class> class S> 
-    using apply = M<R(P&, T...)>;
-};
-
-template<class Sig, class P, template<class> class M, template<class, class> class Self>
-using choose_member_impl_t =
-    typename ::boost::type_erasure::detail::choose_member_impl<
-        Sig (::boost::type_erasure::detail::dummy::*)
-    >::template apply<P, M, Self>;
-
-template<class Sig, class T, class ID>
-struct member_interface_chooser
-{
-    template<class Base, template<class, class> class C, template<class...> class M>
-    using apply = Base;
-};
-
-template<class R, class T, class... A>
-struct member_interface_chooser<R(A...), T, T>
-{
-    template<class Base, template<class, class> class C, template<class...> class M>
-    using apply = ::boost::type_erasure::detail::choose_member_interface<
-        ::boost::type_erasure::placeholder_of_t<Base>,
-        M,
-        R(A...), C<R(A...), T>, Base, T>;
-};
-
-template<class R, class T, class... A>
-struct member_interface_chooser<R(A...), const T, T>
-{
-    template<class Base, template<class, class> class C, template<class...> class M>
-    using apply = M<R(A...), C<R(A...), const T>, Base, const T>;
-};
-
-template<class Sig, class T, template<class, class> class C, template<class...> class M>
-struct member_choose_interface
-{
-    template<class Concept, class Base, class ID>
-    using apply = typename ::boost::type_erasure::detail::member_interface_chooser<Sig, T, ID>::template apply<Base, C, M>;
-};
-
-}
-}
-}
-
-#define BOOST_TYPE_ERASURE_MEMBER_I(concept_name, function_name)            \
-template<class Sig, class T = ::boost::type_erasure::_self>                 \
-struct concept_name;                                                        \
-                                                                            \
-namespace boost_type_erasure_impl {                                         \
-                                                                            \
-template<class Sig, class T>                                                \
-using concept_name ## self = concept_name<Sig, T>;                          \
-                                                                            \
-template<class Sig, class Concept, class Base, class ID, class Enable = void>\
-struct concept_name ## _member_interface;                                   \
-                                                                            \
-template<class R, class... A, class Concept, class Base, class ID, class V> \
-struct concept_name ## _member_interface<R(A...), Concept, Base, ID, V> : Base\
-{                                                                           \
-    typedef void _boost_type_erasure_has_member ## function_name;           \
-    ::boost::type_erasure::rebind_any_t<Base, R> function_name(::boost::type_erasure::as_param_t<Base, A>... a)\
-    { return ::boost::type_erasure::call(Concept(), *this, std::forward<A>(a)...); }\
-};                                                                          \
-                                                                            \
-template<class R, class... A, class Concept, class Base, class ID>          \
-struct concept_name ## _member_interface<R(A...), Concept, Base, ID,        \
-    typename Base::_boost_type_erasure_has_member ## function_name> : Base  \
-{                                                                           \
-    using Base::function_name;                                              \
-    ::boost::type_erasure::rebind_any_t<Base, R> function_name(::boost::type_erasure::as_param_t<Base, A>... a)\
-    { return ::boost::type_erasure::call(Concept(), *this, std::forward<A>(a)...); }\
-};                                                                          \
-                                                                            \
-template<class R, class... A, class Concept, class Base, class ID, class V> \
-struct concept_name ## _member_interface<R(A...), Concept, Base, const ID, V> : Base\
-{                                                                           \
-    typedef void _boost_type_erasure_has_member ## function_name;           \
-    ::boost::type_erasure::rebind_any_t<Base, R> function_name(::boost::type_erasure::as_param_t<Base, A>... a) const\
-    { return ::boost::type_erasure::call(Concept(), *this, std::forward<A>(a)...); }\
-};                                                                          \
-                                                                            \
-template<class R, class... A, class Concept, class Base, class ID>          \
-struct concept_name ## _member_interface<R(A...), Concept, Base, const ID,  \
-    typename Base::_boost_type_erasure_has_member ## function_name> : Base  \
-{                                                                           \
-    using Base::function_name;                                              \
-    ::boost::type_erasure::rebind_any_t<Base, R> function_name(::boost::type_erasure::as_param_t<Base, A>... a) const\
-    { return ::boost::type_erasure::call(Concept(), *this, std::forward<A>(a)...); }\
-};                                                                          \
-                                                                            \
-template<class Sig>                                                         \
-struct concept_name ## member;                                              \
-                                                                            \
-template<class R, class T0, class... T>                                     \
-struct concept_name ## member<R(T0, T...)> {                                \
-    static R apply(T0 t0, T... t)                                           \
-    { return t0.function_name(std::forward<T>(t)...); }                     \
-};                                                                          \
-                                                                            \
-template<class T0, class... T>                                              \
-struct concept_name ## member<void(T0, T...)> {                             \
-    static void apply(T0 t0, T... t)                                        \
-    { t0.function_name(std::forward<T>(t)...); }                            \
-};                                                                          \
-                                                                            \
-}                                                                           \
-                                                                            \
-template<class Sig, class T>                                                \
-struct concept_name :                                                       \
-    ::boost::type_erasure::detail::choose_member_impl_t<Sig, T,             \
-        boost_type_erasure_impl::concept_name##member,                      \
-        boost_type_erasure_impl::concept_name##self                         \
-    >                                                                       \
-{};                                                                         \
-                                                                            \
-template<class Sig, class T>                                                \
-::boost::type_erasure::detail::member_choose_interface<Sig, T, concept_name,\
-    boost_type_erasure_impl::concept_name ## _member_interface>             \
-boost_type_erasure_find_interface(concept_name<Sig, T>);
-
-#define BOOST_TYPE_ERASURE_MEMBER_SIMPLE(name, ...) \
-    BOOST_TYPE_ERASURE_MEMBER_I(has_ ## name, name)
-
-#define BOOST_TYPE_ERASURE_MEMBER_NS_I(concept_name, name)  \
-    BOOST_TYPE_ERASURE_MEMBER_I(concept_name, name)
-
-#define BOOST_TYPE_ERASURE_MEMBER_NS(concept_name, name)    \
-    BOOST_TYPE_ERASURE_OPEN_NAMESPACE(concept_name)         \
-    BOOST_TYPE_ERASURE_MEMBER_NS_I(BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(concept_name)), concept_name), name) \
-    BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(concept_name)
-
-#define BOOST_TYPE_ERASURE_MEMBER_NAMED(concept_name, name, ...)    \
-    BOOST_PP_IF(BOOST_PP_IS_BEGIN_PARENS(concept_name),             \
-        BOOST_TYPE_ERASURE_MEMBER_NS,                               \
-        BOOST_TYPE_ERASURE_MEMBER_I)                                \
-    (concept_name, name)
-
-#define BOOST_TYPE_ERASURE_MEMBER_CAT(x, y) x y
-
-#define BOOST_TYPE_ERASURE_MEMBER(name, ...)            \
-    BOOST_TYPE_ERASURE_MEMBER_CAT(                      \
-        BOOST_PP_IF(BOOST_VMD_IS_EMPTY(__VA_ARGS__),    \
-            BOOST_TYPE_ERASURE_MEMBER_SIMPLE,           \
-            BOOST_TYPE_ERASURE_MEMBER_NAMED),           \
-        (name, __VA_ARGS__))
-
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/null.hpp b/contrib/restricted/boost/boost/type_erasure/detail/null.hpp
deleted file mode 100644
index e0c3173704..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/null.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_NULL_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_NULL_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/type_erasure/config.hpp>
-#include <boost/type_erasure/exception.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-template<class Sig>
-struct null_throw;
-
-template<class Concept>
-struct get_null_vtable_entry {
-    typedef ::boost::type_erasure::detail::null_throw<
-        typename ::boost::remove_pointer<typename Concept::type>::type> type;
-};
-
-#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
-
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/detail/null.hpp>
-#define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPE_ERASURE_MAX_ARITY)
-#include BOOST_PP_ITERATE()
-
-#else
-
-template<class R, class... T>
-struct null_throw<R(T...)> {
-    static R value(T...) { 
-        BOOST_THROW_EXCEPTION(::boost::type_erasure::bad_function_call());
-    }
-};
-
-#endif
-
-}
-}
-}
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-
-template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-struct null_throw<R(BOOST_PP_ENUM_PARAMS(N, T))> {
-    static R value(BOOST_PP_ENUM_PARAMS(N, T)) { 
-        BOOST_THROW_EXCEPTION(::boost::type_erasure::bad_function_call());
-    }
-};
-
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/vtable.hpp b/contrib/restricted/boost/boost/type_erasure/detail/vtable.hpp
deleted file mode 100644
index eb49e41672..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/detail/vtable.hpp
+++ /dev/null
@@ -1,310 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
-#ifndef BOOST_TYPE_ERASURE_DETAIL_VTABLE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DETAIL_VTABLE_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/size.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/expr_if.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/type_erasure/detail/rebind_placeholders.hpp>
-#include <boost/type_erasure/config.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-
-template<class... T>
-struct stored_arg_pack;
-
-template<class It, class End, class... T>
-struct make_arg_pack_impl
-{
-    typedef typename make_arg_pack_impl<
-        typename ::boost::mpl::next<It>::type,
-        End,
-        T...,
-        typename ::boost::mpl::deref<It>::type
-    >::type type;
-};
-
-template<class End, class... T>
-struct make_arg_pack_impl<End, End, T...>
-{
-    typedef stored_arg_pack<T...> type;
-};
-
-template<class Seq>
-struct make_arg_pack
-{
-    typedef typename make_arg_pack_impl<
-        typename ::boost::mpl::begin<Seq>::type,
-        typename ::boost::mpl::end<Seq>::type
-    >::type type;
-};
-
-template<class Args>
-struct make_vtable_impl;
-
-template<class Seq>
-struct make_vtable
-{
-    typedef typename ::boost::type_erasure::detail::make_vtable_impl<
-        typename ::boost::type_erasure::detail::make_arg_pack<Seq>::type
-    >::type type;
-};
-
-template<class Table, class Args>
-struct make_vtable_init_impl;
-
-template<class Seq, class Table>
-struct make_vtable_init
-{
-    typedef typename make_vtable_init_impl<
-        Table,
-        typename ::boost::type_erasure::detail::make_arg_pack<Seq>::type
-    >::type type;
-};
-
-template<class T>
-struct vtable_entry
-{
-    typename T::type value;
-    vtable_entry() = default;
-    constexpr vtable_entry(typename T::type arg) : value(arg) {}
-};
-
-template<class... T>
-struct compare_vtable;
-
-template<>
-struct compare_vtable<> {
-    template<class S>
-    static bool apply(const S& /*s1*/, const S& /*s2*/)
-    {
-        return true;
-    }
-};
-
-template<class T0, class... T>
-struct compare_vtable<T0, T...> {
-    template<class S>
-    static bool apply(const S& s1, const S& s2)
-    {
-        return static_cast<const vtable_entry<T0>&>(s1).value ==
-            static_cast<const vtable_entry<T0>&>(s2).value &&
-            compare_vtable<T...>::apply(s1, s2);
-    }
-};
-
-template<class... T>
-struct vtable_storage : vtable_entry<T>...
-{
-    vtable_storage() = default;
-
-    constexpr vtable_storage(typename T::type... arg)
-        : vtable_entry<T>(arg)... {}
-
-    template<class Bindings, class Src>
-    void convert_from(const Src& src)
-    {
-        *this = vtable_storage(
-            src.lookup(
-                (typename ::boost::type_erasure::detail::rebind_placeholders<
-                T, Bindings
-            >::type*)0)...);
-    }
-
-    bool operator==(const vtable_storage& other) const
-    { return compare_vtable<T...>::apply(*this, other); }
-
-    template<class U>
-    typename U::type lookup(U*) const
-    {
-        return static_cast<const vtable_entry<U>*>(this)->value;
-    }
-};
-
-// Provide this specialization manually.
-// gcc 4.7.2 fails to instantiate the primary template.
-template<>
-struct vtable_storage<>
-{
-    vtable_storage() = default;
-
-    template<class Bindings, class Src>
-    void convert_from(const Src& /*src*/) {}
-
-    bool operator==(const vtable_storage& /*other*/) const
-    { return true; }
-};
-
-template<class... T>
-struct make_vtable_impl<stored_arg_pack<T...> >
-{
-    typedef vtable_storage<T...> type;
-};
-
-template<class Table, class... T>
-struct vtable_init
-{
-    static constexpr Table value = Table(T::value...);
-};
-
-template<class Table, class... T>
-constexpr Table vtable_init<Table, T...>::value;
-
-template<class Table, class... T>
-struct make_vtable_init_impl<Table, stored_arg_pack<T...> >
-{
-    typedef vtable_init<Table, T...> type;
-};
-
-#else
-
-template<int N>
-struct make_vtable_impl;
-
-template<class Seq>
-struct make_vtable
-{
-    typedef typename make_vtable_impl<
-        (::boost::mpl::size<Seq>::value)>::template apply<Seq>::type type;
-};
-
-template<int N>
-struct make_vtable_init_impl;
-
-template<class Seq, class Table>
-struct make_vtable_init
-{
-    typedef typename make_vtable_init_impl<
-        (::boost::mpl::size<Seq>::value)>::template apply<Seq, Table>::type type;
-};
-
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/detail/vtable.hpp>
-#define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPE_ERASURE_MAX_FUNCTIONS)
-#include BOOST_PP_ITERATE()
-
-#endif
-
-}
-}
-}
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-
-#define BOOST_TYPE_ERASURE_VTABLE_ENTRY(z, n, data)                     \
-    typename BOOST_PP_CAT(T, n)::type BOOST_PP_CAT(t, n);               \
-    typename BOOST_PP_CAT(T, n)::type lookup(BOOST_PP_CAT(T, n)*) const \
-    {                                                                   \
-        return BOOST_PP_CAT(t, n);                                      \
-    }
-
-#define BOOST_TYPE_ERASURE_VTABLE_COMPARE(z, n, data)                   \
-    && BOOST_PP_CAT(t, n) == other.BOOST_PP_CAT(t, n)
-
-#define BOOST_TYPE_ERASURE_VTABLE_INIT(z, n, data)  \
-    BOOST_PP_CAT(data, n)::value
-
-#define BOOST_TYPE_ERASURE_AT(z, n, data)       \
-    typename ::boost::mpl::at_c<data, n>::type
-
-#define BOOST_TYPE_ERASURE_CONVERT_ELEMENT(z, n, data)                  \
-    BOOST_PP_CAT(t, n) = src.lookup(                                    \
-        (typename ::boost::type_erasure::detail::rebind_placeholders<   \
-            BOOST_PP_CAT(T, n), Bindings                                \
-        >::type*)0                                                      \
-    );
-
-#if N != 0
-template<BOOST_PP_ENUM_PARAMS(N, class T)>
-#else
-template<class D = void>
-#endif
-struct BOOST_PP_CAT(vtable_storage, N)
-{
-    BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_VTABLE_ENTRY, ~)
-
-    template<class Bindings, class Src>
-    void convert_from(const Src& BOOST_PP_EXPR_IF(N, src))
-    {
-        BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_CONVERT_ELEMENT, ~)
-    }
-
-    bool operator==(const BOOST_PP_CAT(vtable_storage, N)& BOOST_PP_EXPR_IF(N, other)) const
-    { return true BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_VTABLE_COMPARE, ~); }
-};
-
-template<>
-struct make_vtable_impl<N>
-{
-    template<class Seq>
-    struct apply
-    {
-        typedef ::boost::type_erasure::detail::BOOST_PP_CAT(vtable_storage, N)<
-            BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_AT, Seq)
-        > type;
-    };
-};
-template<class Table BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-struct BOOST_PP_CAT(vtable_init, N)
-{
-    static const Table value;
-};
-
-template<class Table BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-const Table BOOST_PP_CAT(vtable_init, N)<
-    Table BOOST_PP_ENUM_TRAILING_PARAMS(N, T)>::value =
-{
-    BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_VTABLE_INIT, T)
-};
-
-template<>
-struct make_vtable_init_impl<N>
-{
-    template<class Seq, class Table>
-    struct apply
-    {
-        typedef ::boost::type_erasure::detail::BOOST_PP_CAT(vtable_init, N)<
-            Table
-            BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_AT, Seq)
-        > type;
-    };
-};
-
-#undef BOOST_TYPE_ERASURE_CONVERT_ELEMENT
-#undef BOOST_TYPE_ERASURE_AT
-#undef BOOST_TYPE_ERASURE_VTABLE_INIT
-#undef BOOST_TYPE_ERASURE_VTABLE_COMPARE
-#undef BOOST_TYPE_ERASURE_VTABLE_ENTRY
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/dynamic_any_cast.hpp b/contrib/restricted/boost/boost/type_erasure/dynamic_any_cast.hpp
deleted file mode 100644
index 6f0939e00d..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/dynamic_any_cast.hpp
+++ /dev/null
@@ -1,242 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2015 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DYNAMIC_ANY_CAST_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DYNAMIC_ANY_CAST_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/binding_of.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/dynamic_binding.hpp>
-#include <boost/type_erasure/concept_of.hpp>
-#include <boost/type_erasure/placeholder_of.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/binding.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/set.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-namespace detail {
-
-template<class P, class P2, class Any>
-struct make_ref_placeholder;
-
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2, const Any&> { typedef const P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2, Any&> { typedef P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&, const Any&> { typedef P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&, Any&> { typedef P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, const P2&, const Any&> { typedef const P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, const P2&, Any&> { typedef const P& type; };
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<class P, class P2, class Any>
-struct make_ref_placeholder { typedef P&& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&, Any> { typedef P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, const P2&, Any> { typedef const P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&&, Any> { typedef P&& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&&, const Any&> { typedef const P& type; };
-template<class P, class P2, class Any>
-struct make_ref_placeholder<P, P2&&, Any&> { typedef P& type; };
-#endif
-
-template<class R, class Tag>
-struct make_result_placeholder_map
-{
-    typedef ::boost::mpl::map<
-        ::boost::mpl::pair<
-            typename ::boost::remove_const<
-                typename ::boost::remove_reference<
-                    typename ::boost::type_erasure::placeholder_of<R>::type
-                >::type
-            >::type,
-            typename ::boost::remove_const<
-                typename ::boost::remove_reference<
-                    Tag
-                >::type
-            >::type
-        >
-    > type;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<class R, class Any, class Map>
-R dynamic_any_cast_impl(Any&& arg, const static_binding<Map>& map)
-#else
-template<class R, class Any, class Map>
-R dynamic_any_cast_impl(Any& arg, const static_binding<Map>& map)
-#endif
-{
-    typedef typename ::boost::remove_const<typename ::boost::remove_reference<Any>::type>::type src_type;
-    typedef typename ::boost::type_erasure::detail::normalize_concept<
-        typename ::boost::type_erasure::concept_of<src_type>::type
-    >::type normalized;
-    typedef typename ::boost::mpl::fold<
-        normalized,
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-        ::boost::mpl::set0<>,
-#else
-        ::boost::mp11::mp_list<>,
-#endif
-        ::boost::type_erasure::detail::get_placeholders<
-            ::boost::mpl::_2,
-            ::boost::mpl::_1
-        >
-    >::type placeholders;
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-    typedef ::boost::type_erasure::detail::substitution_map< ::boost::mpl::map0<> > identity_map;
-#else
-    typedef ::boost::type_erasure::detail::make_identity_placeholder_map<normalized> identity_map;
-#endif
-    ::boost::type_erasure::dynamic_binding<placeholders> my_binding(
-        ::boost::type_erasure::binding_of(arg),
-        ::boost::type_erasure::make_binding<identity_map>());
-    typedef typename ::boost::remove_const<
-        typename ::boost::remove_reference<
-            typename ::boost::type_erasure::placeholder_of<R>::type
-        >::type
-    >::type result_placeholder;
-    ::boost::type_erasure::binding< typename ::boost::type_erasure::concept_of<R>::type> new_binding(
-        my_binding,
-        map);
-    typedef ::boost::type_erasure::any<
-        typename ::boost::type_erasure::concept_of<R>::type,
-        typename ::boost::type_erasure::detail::make_ref_placeholder<
-            result_placeholder,
-            typename ::boost::type_erasure::placeholder_of<src_type>::type,
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-            Any
-#else
-            Any&
-#endif
-        >::type
-    > result_ref_type;
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    return result_ref_type(std::forward<Any>(arg), new_binding);
-#else
-    return result_ref_type(arg, new_binding);
-#endif
-}
-
-}
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-/**
- * Downcasts or crosscasts an @ref any.
- *
- * \pre @c R and @c Any must both be specializations of @ref any.
- * \pre PlaceholderMap must be an MPL map with a key
- *      for every non-deduced placeholder used by R.
- *      The value associated with each key should
- *      be the corresponding placeholder in Any.
- * \pre The concept of Any must include @ref typeid_, for every
- *      @ref placeholder which is used by R.
- * 
- * The single argument form can only be used when @c R uses
- * a single non-deduced placeholder.
- *
- * \throws bad_any_cast if the concepts used by R were
- *         not previously registered via a call to
- *         \register_binding.
- *
- * Example:
- * \code
- * // Assume that typeid_<>, copy_constructible<>, and incrementable<>
- * // have all been registered for int.
- * any<mpl::vector<typeid_<>, copy_constructible<> > > x(1);
- * typedef any<
- *     mpl::vector<
- *         typeid_<>,
- *         copy_constructible<>,
- *         incrementable<>
- *     >
- * > incrementable_any;
- * auto y = dynamic_any_cast<incrementable_any>(x);
- * ++y;
- * assert(any_cast<int>(y) == 2);
- * \endcode
- */
-template<class R, class Any>
-R dynamic_any_cast(Any&& arg);
-
-/**
- * \overload
- */
-template<class R, class Any, class Map>
-R dynamic_any_cast(Any&& arg, const static_binding<Map>&);
-
-#else
-
-template<class R, class Concept, class Tag>
-R dynamic_any_cast(const any<Concept, Tag>& arg)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(arg,
-        ::boost::type_erasure::make_binding<typename ::boost::type_erasure::detail::make_result_placeholder_map<R, Tag>::type>());
-}
-
-template<class R, class Concept, class Tag>
-R dynamic_any_cast(any<Concept, Tag>& arg)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(arg,
-        ::boost::type_erasure::make_binding<typename ::boost::type_erasure::detail::make_result_placeholder_map<R, Tag>::type>());
-}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<class R, class Concept, class Tag>
-R dynamic_any_cast(any<Concept, Tag>&& arg)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(::std::move(arg),
-        ::boost::type_erasure::make_binding<typename ::boost::type_erasure::detail::make_result_placeholder_map<R, Tag>::type>());
-}
-#endif
-
-template<class R, class Concept, class Tag, class Map>
-R dynamic_any_cast(const any<Concept, Tag>& arg, const static_binding<Map>& map)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(arg, map);
-}
-
-template<class R, class Concept, class Tag, class Map>
-R dynamic_any_cast(any<Concept, Tag>& arg, const static_binding<Map>& map)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(arg, map);
-}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<class R, class Concept, class Tag, class Map>
-R dynamic_any_cast(any<Concept, Tag>&& arg, const static_binding<Map>& map)
-{
-    return ::boost::type_erasure::detail::dynamic_any_cast_impl<R>(::std::move(arg), map);
-}
-#endif
-
-#endif
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/dynamic_binding.hpp b/contrib/restricted/boost/boost/type_erasure/dynamic_binding.hpp
deleted file mode 100644
index de097bc2b2..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/dynamic_binding.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2015 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_DYNAMIC_BINDING_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_DYNAMIC_BINDING_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/dynamic_vtable.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * Maps a set of placeholders to actual types.
- */
-template<class PlaceholderList>
-class dynamic_binding
-{
-public:
-    template<class Map>
-    dynamic_binding(const static_binding<Map>&)
-    {
-        impl.template init<Map>();
-    }
-    template<class Concept, class Map>
-    dynamic_binding(const binding<Concept>& other, const static_binding<Map>&)
-    {
-        impl.template convert_from<Map>(*other.impl.table);
-    }
-private:
-    template<class Concept>
-    friend class binding;
-    typename ::boost::type_erasure::detail::make_dynamic_vtable<PlaceholderList>::type impl;
-};
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/free.hpp b/contrib/restricted/boost/boost/type_erasure/free.hpp
deleted file mode 100644
index 23d1a67856..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/free.hpp
+++ /dev/null
@@ -1,487 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_FREE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_FREE_HPP_INCLUDED
-
-#include <boost/detail/workaround.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_trailing.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/control/if.hpp>
-#include <boost/preprocessor/punctuation/is_begin_parens.hpp>
-#include <boost/vmd/is_empty.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/type_erasure/detail/macro.hpp>
-#include <boost/type_erasure/detail/const.hpp>
-#include <boost/type_erasure/config.hpp>
-#include <boost/type_erasure/derived.hpp>
-#include <boost/type_erasure/rebind_any.hpp>
-#include <boost/type_erasure/param.hpp>
-#include <boost/type_erasure/is_placeholder.hpp>
-#include <boost/type_erasure/call.hpp>
-#include <boost/type_erasure/concept_interface.hpp>
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
-    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
-    defined(BOOST_TYPE_ERASURE_DOXYGEN) || \
-    BOOST_WORKAROUND(BOOST_MSVC, == 1800)
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_TYPE_ERASURE_MAX_ARITY, class T, void)>
-struct first_placeholder {
-    typedef typename ::boost::mpl::eval_if<is_placeholder<T0>,
-        ::boost::mpl::identity<T0>,
-        first_placeholder<BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_TYPE_ERASURE_MAX_ARITY, T)>
-    >::type type;
-};
-
-template<>
-struct first_placeholder<> {};
-
-template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_TYPE_ERASURE_MAX_ARITY, class T, void)>
-struct first_placeholder_index :
-    ::boost::mpl::eval_if<is_placeholder<T0>,
-        ::boost::mpl::int_<0>,
-        ::boost::mpl::next<first_placeholder_index<BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_TYPE_ERASURE_MAX_ARITY, T)> >
-    >::type
-{};
-
-}
-}
-}
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_QUALIFIED_ID(seq, N) \
-    BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq)<R(BOOST_PP_ENUM_PARAMS(N, T))>
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_UNQUALIFIED_PARAM_TYPE(z, n, data) \
-    typename ::boost::remove_cv<typename ::boost::remove_reference<BOOST_PP_CAT(T, n)>::type>::type
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_PARAM_TYPE(z, n, data)                      \
-    typename ::boost::mpl::eval_if_c<(_boost_type_erasure_free_p_idx::value == n), \
-        ::boost::type_erasure::detail::maybe_const_this_param<BOOST_PP_CAT(T, n), Base>,    \
-        ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(T, n)>           \
-    >::type BOOST_PP_CAT(t, n)
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_FORWARD_I(z, n, data) ::std::forward<BOOST_PP_CAT(T, n)>(BOOST_PP_CAT(t, n))
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_FORWARD(n) BOOST_PP_ENUM(n, BOOST_TYPE_ERASURE_FREE_FORWARD_I, ~)
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_FORWARD_PARAM_I(z, n, data) \
-    ::std::forward<typename ::boost::mpl::eval_if_c<(_boost_type_erasure_free_p_idx::value == n), \
-        ::boost::type_erasure::detail::maybe_const_this_param<BOOST_PP_CAT(T, n), Base>,    \
-        ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(T, n)>           \
-    >::type>(BOOST_PP_CAT(t, n))
-
-#else
-
-#define BOOST_TYPE_ERASURE_FREE_FORWARD(n) BOOST_PP_ENUM_PARAMS(n, t)
-#define BOOST_TYPE_ERASURE_FREE_FORWARD_PARAM_I(z, n, data) BOOST_PP_CAT(t, n)
-
-#endif
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_II(qual_name, concept_name, function_name, N)  \
-    BOOST_TYPE_ERASURE_OPEN_NAMESPACE(qual_name)                        \
-                                                                        \
-    template<class Sig>                                                 \
-    struct concept_name;                                                \
-                                                                        \
-    template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>         \
-    struct concept_name<R(BOOST_PP_ENUM_PARAMS(N, T))> {                \
-        static R apply(BOOST_PP_ENUM_BINARY_PARAMS(N, T, t))            \
-        { return function_name(BOOST_TYPE_ERASURE_FREE_FORWARD(N)); }   \
-    };                                                                  \
-                                                                        \
-    template<BOOST_PP_ENUM_PARAMS(N, class T)>                          \
-    struct concept_name<void(BOOST_PP_ENUM_PARAMS(N, T))> {             \
-        static void apply(BOOST_PP_ENUM_BINARY_PARAMS(N, T, t))         \
-        { function_name(BOOST_TYPE_ERASURE_FREE_FORWARD(N)); }          \
-    };                                                                  \
-                                                                        \
-    BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(qual_name)                       \
-                                                                        \
-    namespace boost {                                                   \
-    namespace type_erasure {                                            \
-                                                                        \
-    template<class R BOOST_PP_ENUM_TRAILING_PARAMS(N, class T), class Base> \
-    struct concept_interface<                                           \
-        BOOST_TYPE_ERASURE_FREE_QUALIFIED_ID(qual_name, N),             \
-        Base,                                                           \
-        typename ::boost::type_erasure::detail::first_placeholder<      \
-            BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_FREE_UNQUALIFIED_PARAM_TYPE, ~)>::type  \
-    > : Base {                                                          \
-        typedef typename ::boost::type_erasure::detail::first_placeholder_index<    \
-            BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_FREE_UNQUALIFIED_PARAM_TYPE, ~)>::type  \
-            _boost_type_erasure_free_p_idx;                             \
-        friend typename ::boost::type_erasure::rebind_any<Base, R>::type function_name(  \
-            BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_FREE_PARAM_TYPE, ~))    \
-        {                                                               \
-            return ::boost::type_erasure::call(                         \
-                BOOST_TYPE_ERASURE_FREE_QUALIFIED_ID(qual_name, N)()    \
-                BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FREE_FORWARD_PARAM_I, ~)); \
-        }                                                               \
-    };                                                                  \
-                                                                        \
-    }                                                                   \
-    }
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_I(namespace_name, concept_name, function_name, N)\
-    BOOST_TYPE_ERASURE_FREE_II(namespace_name, concept_name, function_name, N)
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-/**
- * \brief Defines a primitive concept for a free function.
- *
- * \param concept_name is the name of the concept to declare.
- *        If it is omitted it defaults to <code>has_ ## function_name</code>
- * \param function_name is the name of the function.
- *
- * The declaration of the concept is
- * \code
- * template<class Sig>
- * struct concept_name;
- * \endcode
- * where Sig is a function type giving the
- * signature of the function.
- *
- * This macro can only be used at namespace scope.
- *
- * Example:
- *
- * \code
- * BOOST_TYPE_ERASURE_FREE(to_string)
- * typedef has_to_string<std::string(_self const&)> to_string_concept;
- * \endcode
- *
- * In C++03, the macro can only be used in the global namespace and
- * is defined as:
- *
- * \code
- * #define BOOST_TYPE_ERASURE_FREE(qualified_name, function_name, N)
- * \endcode
- *
- * Example:
- *
- * \code
- * BOOST_TYPE_ERASURE_FREE((boost)(has_to_string), to_string, 1)
- * \endcode
- *
- * For backwards compatibility, this form is always accepted.
- */
-#define BOOST_TYPE_ERASURE_FREE(concept_name, function_name)
-
-#else
-
-#define BOOST_TYPE_ERASURE_FREE(qualified_name, function_name, N)                           \
-    BOOST_TYPE_ERASURE_FREE_I(                                                              \
-        qualified_name,                                                                     \
-        BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
-        function_name,                                                                      \
-        N)
-
-#endif
-
-#else
-
-namespace boost {
-namespace type_erasure {
-    
-template<int... N>
-struct index_list {};
-
-namespace detail {
-    
-template<class... T>
-struct first_placeholder;
-
-template<class T0, class... T>
-struct first_placeholder<T0, T...> {
-    typedef typename ::boost::mpl::eval_if<is_placeholder<T0>,
-        ::boost::mpl::identity<T0>,
-        first_placeholder<T...>
-    >::type type;
-};
-
-template<>
-struct first_placeholder<> {};
-
-template<class... T>
-struct first_placeholder_index;
-
-template<class T0, class... T>
-struct first_placeholder_index<T0, T...> :
-    ::boost::mpl::eval_if<is_placeholder<T0>,
-        ::boost::mpl::int_<0>,
-        ::boost::mpl::next<first_placeholder_index<T...> >
-    >::type
-{};
-
-template<class Sig>
-struct transform_free_signature;
-
-template<class T, int N>
-struct push_back_index;
-
-template<int... N, int X>
-struct push_back_index<index_list<N...>, X>
-{
-    typedef index_list<N..., X> type;
-};
-
-template<int N>
-struct make_index_list {
-    typedef typename push_back_index<
-        typename make_index_list<N-1>::type,
-        N-1
-    >::type type;
-};
-
-template<>
-struct make_index_list<0> {
-    typedef index_list<> type;
-};
-
-#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && \
-    !defined(BOOST_NO_CXX11_DECLTYPE)
-
-template<int N>
-using make_index_list_t = typename ::boost::type_erasure::detail::make_index_list<N>::type;
-
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1900)
-
-template<class... T>
-struct first_placeholder_index_ :
-    ::boost::type_erasure::detail::first_placeholder_index<
-        ::boost::remove_cv_t< ::boost::remove_reference_t<T> >...
-    >
-{};
-template<class... T>
-using first_placeholder_index_t =
-    typename ::boost::type_erasure::detail::first_placeholder_index_<T...>::type;
-
-#else
-
-template<class... T>
-using first_placeholder_index_t =
-    typename ::boost::type_erasure::detail::first_placeholder_index<
-        ::boost::remove_cv_t< ::boost::remove_reference_t<T> >...
-    >::type;
-
-#endif
-
-template<class Base, class Tn, int I, class... T>
-using free_param_t =
-    typename ::boost::mpl::eval_if_c<(::boost::type_erasure::detail::first_placeholder_index_t<T...>::value == I),
-            ::boost::type_erasure::detail::maybe_const_this_param<Tn, Base>, \
-            ::boost::type_erasure::as_param<Base, Tn>
-    >::type;
-
-template<class Sig, class ID>
-struct free_interface_chooser
-{
-    template<class Base, template<class> class C, template<class...> class F>
-    using apply = Base;
-};
-
-template<class R, class... A>
-struct free_interface_chooser<
-    R(A...),
-    typename ::boost::type_erasure::detail::first_placeholder<
-        ::boost::remove_cv_t< ::boost::remove_reference_t<A> >...>::type>
-{
-    template<class Base, template<class> class C, template<class...> class F>
-    using apply = F<R(A...), Base,
-        ::boost::type_erasure::detail::make_index_list_t<sizeof...(A)> >;
-};
-
-template<class Sig, template<class> class C, template<class...> class F>
-struct free_choose_interface {
-    template<class Concept, class Base, class ID>
-    using apply = typename free_interface_chooser<Sig, ID>::template apply<Base, C, F>;
-};
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_I(concept_name, function_name)              \
-template<class Sig>                                                         \
-struct concept_name;                                                        \
-                                                                            \
-namespace boost_type_erasure_impl {                                         \
-                                                                            \
-template<class Sig, class Base, class Idx>                                  \
-struct concept_name ## _free_interface;                                     \
-template<class R, class... T, class Base, int... I>                         \
-struct concept_name ## _free_interface<R(T...), Base, ::boost::type_erasure::index_list<I...> > : Base {\
-    friend ::boost::type_erasure::rebind_any_t<Base, R>                     \
-    function_name(                                                          \
-        ::boost::type_erasure::detail::free_param_t<Base, T, I, T...>... t) \
-    {                                                                       \
-        return ::boost::type_erasure::call(                                 \
-            concept_name<R(T...)>(),                                        \
-            std::forward< ::boost::type_erasure::detail::free_param_t<Base, T, I, T...> >(t)...);\
-    }                                                                       \
-};                                                                          \
-                                                                            \
-template<class Sig>                                                         \
-struct concept_name ## free;                                                \
-                                                                            \
-template<class R, class... T>                                               \
-struct concept_name ## free<R(T...)> {                                      \
-    static R apply(T... t)                                                  \
-    { return function_name(std::forward<T>(t)...); }                        \
-};                                                                          \
-                                                                            \
-template<class... T>                                                        \
-struct concept_name ## free<void(T...)> {                                   \
-    static void apply(T... t)                                               \
-    { function_name(std::forward<T>(t)...); }                               \
-};                                                                          \
-                                                                            \
-}                                                                           \
-                                                                            \
-template<class Sig>                                                         \
-struct concept_name :                                                       \
-    boost_type_erasure_impl::concept_name##free<Sig>                        \
-{};                                                                         \
-                                                                            \
-template<class Sig>                                                         \
-::boost::type_erasure::detail::free_choose_interface<Sig, concept_name,     \
-    boost_type_erasure_impl::concept_name ## _free_interface>               \
-boost_type_erasure_find_interface(concept_name<Sig>);
-
-#define BOOST_TYPE_ERASURE_FREE_SIMPLE(name, ...) \
-    BOOST_TYPE_ERASURE_FREE_I(has_ ## name, name)
-
-#define BOOST_TYPE_ERASURE_FREE_NS_I(concept_name, name)  \
-    BOOST_TYPE_ERASURE_FREE_I(concept_name, name)
-
-#define BOOST_TYPE_ERASURE_FREE_NS(concept_name, name)      \
-    BOOST_TYPE_ERASURE_OPEN_NAMESPACE(concept_name)         \
-    BOOST_TYPE_ERASURE_FREE_NS_I(BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(concept_name)), concept_name), name) \
-    BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(concept_name)
-
-#define BOOST_TYPE_ERASURE_FREE_NAMED(concept_name, name, ...)  \
-    BOOST_PP_IF(BOOST_PP_IS_BEGIN_PARENS(concept_name),         \
-        BOOST_TYPE_ERASURE_FREE_NS,                             \
-        BOOST_TYPE_ERASURE_FREE_I)                              \
-    (concept_name, name)
-
-#define BOOST_TYPE_ERASURE_FREE_CAT(x, y) x y
-
-#define BOOST_TYPE_ERASURE_FREE(name, ...)              \
-    BOOST_TYPE_ERASURE_FREE_CAT(                        \
-        BOOST_PP_IF(BOOST_VMD_IS_EMPTY(__VA_ARGS__),    \
-            BOOST_TYPE_ERASURE_FREE_SIMPLE,             \
-            BOOST_TYPE_ERASURE_FREE_NAMED),             \
-        (name, __VA_ARGS__))
-
-#else
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_II(qual_name, concept_name, function_name)  \
-    BOOST_TYPE_ERASURE_OPEN_NAMESPACE(qual_name)                        \
-                                                                        \
-    template<class Sig>                                                 \
-    struct concept_name;                                                \
-                                                                        \
-    template<class R, class... T>                                       \
-    struct concept_name<R(T...)> {                                      \
-        static R apply(T... t)                                          \
-        { return function_name(std::forward<T>(t)...); }                \
-    };                                                                  \
-                                                                        \
-    template<class... T>                                                \
-    struct concept_name<void(T...)> {                                   \
-        static void apply(T... t)                                       \
-        { function_name(std::forward<T>(t)...); }                       \
-    };                                                                  \
-                                                                        \
-    BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(qual_name)                       \
-                                                                        \
-    namespace boost {                                                   \
-    namespace type_erasure {                                            \
-                                                                        \
-    template<class Sig, class Base, class Idx>                          \
-    struct inject ## concept_name;                                      \
-    template<class R, class... T, class Base, int... I>                 \
-    struct inject ## concept_name<R(T...), Base, index_list<I...> > : Base {\
-        typedef typename ::boost::type_erasure::detail::first_placeholder_index<    \
-            typename ::boost::remove_cv<                                \
-                typename ::boost::remove_reference<T>::type             \
-            >::type...                                                  \
-        >::type _boost_type_erasure_free_p_idx;                         \
-        friend typename ::boost::type_erasure::rebind_any<Base, R>::type\
-        function_name(                                                  \
-            typename ::boost::mpl::eval_if_c<(_boost_type_erasure_free_p_idx::value == I), \
-                ::boost::type_erasure::detail::maybe_const_this_param<T, Base>, \
-                ::boost::type_erasure::as_param<Base, T>                \
-            >::type... t)                                               \
-       {                                                                \
-            return ::boost::type_erasure::call(                         \
-                BOOST_TYPE_ERASURE_QUALIFIED_NAME(qual_name)<R(T...)>(),\
-                std::forward<typename ::boost::mpl::eval_if_c<(_boost_type_erasure_free_p_idx::value == I), \
-                    ::boost::type_erasure::detail::maybe_const_this_param<T, Base>, \
-                    ::boost::type_erasure::as_param<Base, T>            \
-                >::type>(t)...);                                        \
-        }                                                               \
-    };                                                                  \
-                                                                        \
-    template<class R, class... T, class Base>                           \
-    struct concept_interface<                                           \
-        BOOST_TYPE_ERASURE_QUALIFIED_NAME(qual_name)<R(T...)>,          \
-        Base,                                                           \
-        typename ::boost::type_erasure::detail::first_placeholder<      \
-            typename ::boost::remove_cv<typename ::boost::remove_reference<T>::type>::type...>::type  \
-    > :  inject ## concept_name<R(T...), Base, typename ::boost::type_erasure::detail::make_index_list<sizeof...(T)>::type>\
-    {};                                                                 \
-                                                                        \
-    }                                                                   \
-    }
-
-    
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_FREE_I(namespace_name, concept_name, function_name)              \
-    BOOST_TYPE_ERASURE_FREE_II(namespace_name, concept_name, function_name)
-
-#define BOOST_TYPE_ERASURE_FREE(qualified_name, function_name, ...)                         \
-    BOOST_TYPE_ERASURE_FREE_I(                                                              \
-        qualified_name,                                                                     \
-        BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
-        function_name)
-
-#endif
-
-}
-}
-}
-
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/is_empty.hpp b/contrib/restricted/boost/boost/type_erasure/is_empty.hpp
deleted file mode 100644
index 3a6c004d61..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/is_empty.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_IS_EMPTY_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_IS_EMPTY_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/access.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/** Returns true for an empty @ref any. */
-template<class T>
-bool is_empty(const T& arg) {
-    return ::boost::type_erasure::detail::access::data(arg).data == 0;
-}
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/is_subconcept.hpp b/contrib/restricted/boost/boost/type_erasure/is_subconcept.hpp
deleted file mode 100644
index c327731094..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/is_subconcept.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_IS_SUBCONCEPT_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_IS_SUBCONCEPT_HPP_INCLUDED
-
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/not.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/find_if.hpp>
-#include <boost/mpl/has_key.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_erasure/detail/normalize.hpp>
-#include <boost/type_erasure/detail/check_map.hpp>
-#include <boost/type_erasure/detail/rebind_placeholders.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-
-namespace boost {
-namespace type_erasure {
-namespace detail {
-
-#ifdef BOOST_TYPE_ERASURE_USE_MP11
-
-template<class S, class K>
-struct mp_set_has_key : ::boost::mp11::mp_set_contains<S, K> {};
-
-template<class Super, class Bindings>
-struct is_subconcept_f
-{
-    template<class T>
-    using apply = ::boost::mp11::mp_set_contains<Super, ::boost::type_erasure::detail::rebind_placeholders_t<T, Bindings> >;
-};
-
-template<class Super>
-struct is_subconcept_f<Super, void>
-{
-    template<class T>
-    using apply = ::boost::mp11::mp_set_contains<Super, T>;
-};
-
-#endif
-
-template<class Sub, class Super, class PlaceholderMap>
-struct is_subconcept_impl {
-#ifndef BOOST_TYPE_ERASURE_USE_MP11
-    typedef typename ::boost::type_erasure::detail::normalize_concept<
-        Super>::concept_set super_set;
-
-    typedef typename ::boost::type_erasure::detail::get_placeholder_normalization_map<
-        Super
-    >::type placeholder_subs_super;
-    
-    typedef typename ::boost::type_erasure::detail::normalize_concept<
-        Sub>::type normalized_sub;
-    typedef typename ::boost::type_erasure::detail::get_placeholder_normalization_map<
-        Sub
-    >::type placeholder_subs_sub;
-
-    typedef typename ::boost::mpl::eval_if< ::boost::is_same<PlaceholderMap, void>,
-        boost::mpl::identity<void>,
-        ::boost::type_erasure::detail::convert_deductions<
-            PlaceholderMap,
-            placeholder_subs_sub,
-            placeholder_subs_super
-        >
-    >::type bindings;
-
-    typedef typename ::boost::mpl::if_< ::boost::is_same<PlaceholderMap, void>,
-        ::boost::mpl::_1,
-        ::boost::type_erasure::detail::rebind_placeholders<
-            ::boost::mpl::_1,
-            bindings
-        >
-    >::type transform;
-
-    typedef typename ::boost::is_same<
-        typename ::boost::mpl::find_if<normalized_sub,
-            ::boost::mpl::not_<
-                ::boost::mpl::has_key<
-                    super_set,
-                    transform
-                >
-            >
-        >::type,
-        typename ::boost::mpl::end<normalized_sub>::type
-    >::type type;
-#else
-    typedef ::boost::type_erasure::detail::normalize_concept_t<Super> super_set;
-
-    typedef ::boost::type_erasure::detail::get_placeholder_normalization_map_t<
-        Super
-    > placeholder_subs_super;
-    
-    typedef ::boost::type_erasure::detail::normalize_concept_t<Sub> normalized_sub;
-    typedef ::boost::type_erasure::detail::get_placeholder_normalization_map_t<
-        Sub
-    > placeholder_subs_sub;
-    typedef ::boost::mp11::mp_eval_if_c< ::boost::is_same<PlaceholderMap, void>::value,
-        void,
-        ::boost::type_erasure::detail::convert_deductions_t,
-        PlaceholderMap,
-        placeholder_subs_sub,
-        placeholder_subs_super
-    > bindings;
-
-    typedef typename ::boost::mp11::mp_all_of<
-        normalized_sub,
-        ::boost::type_erasure::detail::is_subconcept_f<super_set, bindings>::template apply
-    > type;
-#endif
-};
-
-}
-
-/**
- * @ref is_subconcept is a boolean metafunction that determines whether
- * one concept is a sub-concept of another.
- *
- * \code
- * is_subconcept<incrementable<>, incrementable<> >             -> true
- * is_subconcept<incrementable<>, addable<> >                   -> false
- * is_subconcept<incrementable<_a>, forward_iterator<_iter>,
- *   mpl::map<mpl::pair<_a, _iter> > >                          -> true
- * \endcode
- *
- * \tparam Sub The sub concept
- * \tparam Super The super concept
- * \tparam PlaceholderMap (optional) An MPL map with keys for
- *   every non-deduced placeholder in Sub.  The
- *   associated value of each key is the corresponding placeholder
- *   in Super.  If @c PlaceholderMap is omitted, @c Super and @c Sub
- *   are presumed to use the same set of placeholders.
- */
-template<class Sub, class Super, class PlaceholderMap = void>
-struct is_subconcept :
-    ::boost::mpl::and_<
-        ::boost::type_erasure::detail::check_map<Sub, PlaceholderMap>,
-        ::boost::type_erasure::detail::is_subconcept_impl<Sub, Super, PlaceholderMap>
-    >::type
-{};
-
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-template<class Sub, class Super>
-struct is_subconcept<Sub, Super, void> :
-    ::boost::type_erasure::detail::is_subconcept_impl<Sub, Super, void>::type
-{};
-template<class Sub, class Super, class PlaceholderMap>
-struct is_subconcept<Sub, Super, static_binding<PlaceholderMap> > :
-    ::boost::mpl::and_<
-        ::boost::type_erasure::detail::check_map<Sub, PlaceholderMap>,
-        ::boost::type_erasure::detail::is_subconcept_impl<Sub, Super, PlaceholderMap>
-    >::type
-{};
-#endif
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/iterator.hpp b/contrib/restricted/boost/boost/type_erasure/iterator.hpp
deleted file mode 100644
index eea471506d..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/iterator.hpp
+++ /dev/null
@@ -1,308 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_ITERATOR_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_ITERATOR_HPP_INCLUDED
-
-#include <iterator>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_erasure/operators.hpp>
-#include <boost/type_erasure/builtin.hpp>
-#include <boost/type_erasure/deduced.hpp>
-#include <boost/type_erasure/is_placeholder.hpp>
-
-namespace boost {
-
-namespace type_erasure {
-
-/** INTERNAL ONLY */
-template<>
-struct is_placeholder< ::boost::use_default> : ::boost::mpl::false_ {};
-
-namespace detail {
-
-template<class T>
-struct iterator_value_type_impl
-{
-    typedef typename ::std::iterator_traits<T>::value_type type;
-};
-
-}
-
-/** INTERNAL ONLY */
-template<class T>
-struct iterator_value_type
-{
-    typedef typename ::boost::mpl::eval_if<
-        ::boost::type_erasure::is_placeholder<T>,
-        ::boost::mpl::identity<void>,
-        ::boost::type_erasure::detail::iterator_value_type_impl<T>
-    >::type type;
-};
-
-template<
-    class Traversal,
-    class T = _self,
-    class Reference = ::boost::use_default,
-    class DifferenceType = ::std::ptrdiff_t,
-    class ValueType = typename deduced<iterator_value_type<T> >::type
->
-struct iterator;
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-/**
- * The @ref iterator concept can be used for any iterator category.
- *
- * \tparam Traversal must be one of @c boost::incrementable_traversal_tag,
- *         @c boost::single_pass_traversal_tag, @c boost::forward_traversal_tag,
- *         @c boost::bidirectional_traversal_tag, and @c boost::random_access_traversal_tag.
- * \tparam T The placeholder representing the iterator.
- * \tparam Reference The reference type.  If it is boost::use_default, then
- *         reference will be value_type&.
- * \tparam DifferenceType The iterator's difference type.
- *
- * The value_type of the iterator is deduced.  To force it to be
- * a specific type, use the @ref same_type concept.
- *
- * Example:
- *
- * \code
- * mpl::vector<
- *   iterator<boost::forward_traversal_tag>,
- *   same_type<iterator<boost::forward_traversal_tag>::value_type, int> > int_it;
- * \endcode
- */
-template<
-    class Traversal,
-    class T = _self,
-    class Reference = boost::use_default,
-    class DifferenceType = std::ptrdiff_t
->
-struct iterator
-{
-    typedef detail::unspecified value_type;
-    typedef Reference reference;
-    typedef DifferenceType difference_type;
-};
-
-template<
-    class T = _self,
-    class Reference = boost::use_default,
-    class DifferenceType = std::ptrdiff_t
->
-struct forward_iterator :
-    iterator<boost::forward_traversal_tag, T, Reference, DifferenceType>
-{};
-
-template<
-    class T = _self,
-    class Reference = boost::use_default,
-    class DifferenceType = std::ptrdiff_t
->
-struct bidirectional_iterator :
-    iterator<boost::bidirectional_traversal_tag, T, Reference, DifferenceType>
-{};
-
-template<
-    class T = _self,
-    class Reference = boost::use_default,
-    class DifferenceType = std::ptrdiff_t
->
-struct random_access_iterator :
-    iterator<boost::random_access_traversal_tag, T, Reference, DifferenceType>
-{
-};
-
-#else
-
-/** INTERNAL ONLY */
-template<class Reference, class ValueType>
-struct iterator_reference
-{
-    typedef Reference type;
-};
-
-/** INTERNAL ONLY */
-template<class ValueType>
-struct iterator_reference< ::boost::use_default, ValueType>
-{
-    typedef ValueType& type;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::no_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    boost::mpl::vector<
-        copy_constructible<T>,
-        constructible<T()>,
-        equality_comparable<T>,
-        dereferenceable<typename iterator_reference<Reference, ValueType>::type, T>,
-        assignable<T>
-    >
-{
-    typedef ValueType value_type;
-    typedef typename iterator_reference<Reference, ValueType>::type reference;
-    typedef DifferenceType difference_type;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::incrementable_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    boost::mpl::vector<
-        iterator< ::boost::no_traversal_tag, T, Reference, DifferenceType>,
-        incrementable<T>
-    >
-{
-    typedef ValueType value_type;
-    typedef typename iterator_reference<Reference, ValueType>::type reference;
-    typedef DifferenceType difference_type;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::single_pass_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    iterator< ::boost::incrementable_traversal_tag, T, Reference, DifferenceType, ValueType>
-{};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::forward_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    iterator< ::boost::incrementable_traversal_tag, T, Reference, DifferenceType, ValueType>
-{};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::bidirectional_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    boost::mpl::vector<
-        iterator< ::boost::incrementable_traversal_tag, T, Reference, DifferenceType, ValueType>,
-        decrementable<T>
-    >
-{
-    typedef ValueType value_type;
-    typedef typename iterator_reference<Reference, ValueType>::type reference;
-    typedef DifferenceType difference_type;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType>
-struct iterator< ::boost::random_access_traversal_tag, T, Reference, DifferenceType, ValueType> :
-    boost::mpl::vector<
-        iterator< ::boost::bidirectional_traversal_tag, T, Reference, DifferenceType, ValueType>,
-        addable<T, DifferenceType, T>,
-        addable<DifferenceType, T, T>,
-        subtractable<T, DifferenceType, T>,
-        subtractable<T, T, DifferenceType>,
-        subscriptable<typename iterator_reference<Reference, ValueType>::type, T, DifferenceType>
-    >
-{
-    typedef ValueType value_type;
-    typedef typename iterator_reference<Reference, ValueType>::type reference;
-    typedef DifferenceType difference_type;
-};
-
-template<
-    class T = _self,
-    class Reference = ::boost::use_default,
-    class DifferenceType = ::std::ptrdiff_t,
-    class ValueType = typename deduced<iterator_value_type<T> >::type
->
-struct forward_iterator :
-    iterator< ::boost::forward_traversal_tag, T, Reference, DifferenceType, ValueType>
-{};
-
-template<
-    class T = _self,
-    class Reference = ::boost::use_default,
-    class DifferenceType = ::std::ptrdiff_t,
-    class ValueType = typename deduced<iterator_value_type<T> >::type
->
-struct bidirectional_iterator :
-    iterator< ::boost::bidirectional_traversal_tag, T, Reference, DifferenceType, ValueType>
-{};
-
-template<
-    class T = _self,
-    class Reference = ::boost::use_default,
-    class DifferenceType = ::std::ptrdiff_t,
-    class ValueType = typename deduced<iterator_value_type<T> >::type
->
-struct random_access_iterator :
-    iterator< ::boost::random_access_traversal_tag, T, Reference, DifferenceType, ValueType>
-{
-};
-
-#endif
-
-/// \cond show_operators
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<iterator< ::boost::no_traversal_tag, T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef typename rebind_any<Base, ValueType>::type value_type;
-    typedef typename rebind_any<
-        Base, 
-        typename iterator_reference<Reference, ValueType>::type
-    >::type reference;
-    typedef DifferenceType difference_type;
-    typedef typename ::boost::mpl::if_< ::boost::is_reference<reference>,
-        typename ::boost::remove_reference<reference>::type*,
-        value_type*
-    >::type pointer;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<iterator< ::boost::forward_traversal_tag, T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::forward_iterator_tag iterator_category;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<forward_iterator<T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::forward_iterator_tag iterator_category;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<iterator< ::boost::bidirectional_traversal_tag, T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::bidirectional_iterator_tag iterator_category;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<bidirectional_iterator<T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::bidirectional_iterator_tag iterator_category;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<iterator< ::boost::random_access_traversal_tag, T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::random_access_iterator_tag iterator_category;
-};
-
-template<class T, class Reference, class DifferenceType, class ValueType, class Base>
-struct concept_interface<random_access_iterator<T, Reference, DifferenceType, ValueType>, Base, T>
-    : Base
-{
-    typedef std::random_access_iterator_tag iterator_category;
-};
-
-/// \endcond
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/member.hpp b/contrib/restricted/boost/boost/type_erasure/member.hpp
deleted file mode 100644
index d358cbad20..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/member.hpp
+++ /dev/null
@@ -1,289 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2012-2013 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_MEMBER_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_MEMBER_HPP_INCLUDED
-
-#include <boost/type_erasure/detail/member11.hpp>
-
-#ifndef BOOST_TYPE_ERASURE_MEMBER
-
-#include <boost/detail/workaround.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/dec.hpp>
-#include <boost/preprocessor/comma_if.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_trailing.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/elem.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/type_erasure/detail/macro.hpp>
-#include <boost/type_erasure/detail/const.hpp>
-#include <boost/type_erasure/rebind_any.hpp>
-#include <boost/type_erasure/placeholder.hpp>
-#include <boost/type_erasure/call.hpp>
-#include <boost/type_erasure/concept_interface.hpp>
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_ARG(z, n, data)  \
-    typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(A, n)>::type BOOST_PP_CAT(a, n)
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
-    defined(BOOST_TYPE_ERASURE_DOXYGEN) || \
-    BOOST_WORKAROUND(BOOST_MSVC, == 1800)
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(seq, N) \
-    BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq)<R(BOOST_PP_ENUM_PARAMS(N, A)), T>
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, X) BOOST_PP_ENUM_TRAILING_PARAMS(N, X)
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, X) BOOST_PP_ENUM_PARAMS(N, X)
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_FORWARD(z, n, data) ::std::forward<BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 0, data), n)>(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2, 1, data), n))
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_MEMBER_FORWARD, (X, x))
-/** INTERNAL ONLY*/
-#define BOOST_TYPE_ERASURE_FORWARD_REBIND1(z, n, data) ::std::forward<typename ::boost::type_erasure::as_param<Base, BOOST_PP_CAT(A, n)>::type>(BOOST_PP_CAT(a, n))
-/** INTERNAL ONLY*/
-#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) BOOST_PP_ENUM_TRAILING(N, BOOST_TYPE_ERASURE_FORWARD_REBIND1, ~)
-
-#else
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) BOOST_PP_ENUM_PARAMS(N, x)
-/** INTERNAL ONLY*/
-#define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) BOOST_PP_ENUM_TRAILING_PARAMS(N, a)
-
-#endif
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_PARAMS(N, X) BOOST_PP_ENUM_TRAILING_PARAMS(N, X)
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, X, x) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, X, x)
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N) BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_MEMBER_ARG, ~)
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-/**
- * \brief Defines a primitive concept for a member function.
- *
- * \param concept_name is the name of the concept to declare.
- *        If it is omitted it defaults to <code>has_ ## member</code>
- * \param member is the name of the member function.
- *
- * The declaration of the concept is
- * \code
- * template<class Sig, class T = _self>
- * struct concept_name;
- * \endcode
- * where @c Sig is a function type giving the
- * signature of the member function, and @c T is the
- * object type.  @c T may be const-qualified for
- * const member functions.  @c concept_name<R(A...) const, T>
- * is an alias for @c concept_name<R(A...), const T>.
- *
- * This macro can only be used at namespace scope.
- *
- * Example:
- *
- * \code
- * namespace boost {
- * BOOST_TYPE_ERASURE_MEMBER(push_back)
- * }
- * typedef boost::has_push_back<void(int)> push_back_concept;
- * \endcode
- *
- * The concept defined by this function may be specialized to
- * provide a concept_map.  The class object will be passed by
- * reference as the first parameter.
- *
- * \code
- * template<>
- * struct has_push_back<void(int), std::list<int> > {
- *   static void apply(std::list<int>& l, int i) { l.push_back(i); }
- * };
- * \endcode
- *
- * In C++03, the macro can only be used in the global namespace and
- * is defined as:
- *
- * \code
- * #define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N)
- * \endcode
- *
- * Example:
- *
- * \code
- * BOOST_TYPE_ERASURE_MEMBER((boost)(has_push_back), push_back, 1)
- * typedef boost::has_push_back<void(int), _self> push_back_concept;
- * \endcode
- *
- * For backwards compatibility, this form is always accepted.
- */
-#define BOOST_TYPE_ERASURE_MEMBER(concept_name, member) /**/
-
-#else
-
-#define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N)                                \
-    BOOST_TYPE_ERASURE_MEMBER_I(                                                            \
-        qualified_name,                                                                     \
-        BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
-        member,                                                                             \
-        N)
-
-#endif
-
-#else
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(seq, N) \
-    BOOST_TYPE_ERASURE_QUALIFIED_NAME(seq)<R(A...), T>
-
-#define BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, X) , class... A
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, X) X...
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#   define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) ::std::forward<X>(x)...
-#   define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) , ::std::forward<typename ::boost::type_erasure::as_param<Base, A>::type>(a)...
-#else
-#   define BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, X, x) x...
-#   define BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N) , a...
-#endif
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_PARAMS(N, X) , X...
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, X, x) , X... x
-#define BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N) typename ::boost::type_erasure::as_param<Base, A>::type... a
-
-
-#define BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, ...)                              \
-    BOOST_TYPE_ERASURE_MEMBER_I(                                                            \
-        qualified_name,                                                                     \
-        BOOST_PP_SEQ_ELEM(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(qualified_name)), qualified_name), \
-        member,                                                                             \
-        N)
-
-#endif
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_II(qual_name, concept_name, member, N)                        \
-    BOOST_TYPE_ERASURE_OPEN_NAMESPACE(qual_name)                                                \
-    template<class Sig, class T = ::boost::type_erasure::_self>                                 \
-    struct concept_name;                                                                        \
-    template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T>               \
-    struct concept_name<R(BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, A)), T> {                    \
-        static R apply(T& t BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, A, a))     \
-        { return t.member(BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, A, a)); }                 \
-    };                                                                                          \
-    template<class T BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A)>                        \
-    struct concept_name<void(BOOST_TYPE_ERASURE_MEMBER_ENUM_PARAMS(N, A)), T> {                 \
-        static void apply(T& t BOOST_TYPE_ERASURE_MEMBER_ENUM_TRAILING_BINARY_PARAMS(N, A, a))  \
-        { t.member(BOOST_TYPE_ERASURE_MEMBER_FORWARD_PARAMS(N, A, a)); }                        \
-    };                                                                                          \
-    BOOST_TYPE_ERASURE_CLOSE_NAMESPACE(qual_name)                                               \
-    namespace boost {                                                                           \
-    namespace type_erasure {                                                                    \
-    template<                                                                                   \
-        class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A),                             \
-        class T, class Base, class Enable>                                                      \
-    struct concept_interface<                                                                   \
-        BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N),                                   \
-        Base,                                                                                   \
-        typename ::boost::enable_if<                                                            \
-            ::boost::type_erasure::detail::should_be_non_const<T, Base>,                        \
-            typename ::boost::remove_const<T>::type                                             \
-        >::type,                                                                                \
-        Enable                                                                                  \
-    > : Base                                                                                    \
-    {                                                                                           \
-        typedef void BOOST_PP_CAT(_boost_type_erasure_has_member, member);                      \
-        typename rebind_any<Base, R>::type member(                                              \
-            BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N))                                             \
-        {                                                                                       \
-            return ::boost::type_erasure::call(                                                 \
-                BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(),                         \
-                *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N));                             \
-        }                                                                                       \
-    };                                                                                          \
-    template<                                                                                   \
-        class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A),                             \
-        class T, class Base, class Enable>                                                      \
-    struct concept_interface<                                                                   \
-        BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N),                                   \
-        Base,                                                                                   \
-        typename ::boost::enable_if<                                                            \
-            ::boost::type_erasure::detail::should_be_const<T, Base>,                            \
-            typename ::boost::remove_const<T>::type                                             \
-        >::type,                                                                                \
-        Enable                                                                                  \
-    > : Base                                                                                    \
-    {                                                                                           \
-        typedef void BOOST_PP_CAT(_boost_type_erasure_has_member, member);                      \
-        typename rebind_any<Base, R>::type member(                                              \
-            BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) const                                       \
-        {                                                                                       \
-            return ::boost::type_erasure::call(                                                 \
-                BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(),                         \
-                *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N));                             \
-        }                                                                                       \
-    };                                                                                          \
-    template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T, class Base>   \
-    struct concept_interface<                                                                   \
-        BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N),                                   \
-        Base,                                                                                   \
-        typename ::boost::enable_if<                                                            \
-            ::boost::type_erasure::detail::should_be_non_const<T, Base>,                        \
-            typename ::boost::remove_const<T>::type                                             \
-        >::type,                                                                                \
-        typename Base::BOOST_PP_CAT(_boost_type_erasure_has_member, member)> : Base             \
-    {                                                                                           \
-        using Base::member;                                                                     \
-        typename rebind_any<Base, R>::type member(                                              \
-            BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N))                                             \
-        {                                                                                       \
-            return ::boost::type_erasure::call(                                                 \
-                BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(),                         \
-                *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N));                             \
-        }                                                                                       \
-    };                                                                                          \
-    template<class R BOOST_TYPE_ERASURE_MEMBER_TPL_ARG_LIST(N, class A), class T, class Base>   \
-    struct concept_interface<                                                                   \
-        BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N),                                   \
-        Base,                                                                                   \
-        typename ::boost::enable_if<                                                            \
-            ::boost::type_erasure::detail::should_be_const<T, Base>,                            \
-            typename ::boost::remove_const<T>::type                                             \
-        >::type,                                                                                \
-        typename Base::BOOST_PP_CAT(_boost_type_erasure_has_member, member)> : Base             \
-    {                                                                                           \
-        using Base::member;                                                                     \
-        typename rebind_any<Base, R>::type member(                                              \
-            BOOST_TYPE_ERASURE_MEMBER_ENUM_ARGS(N)) const                                       \
-        {                                                                                       \
-            return ::boost::type_erasure::call(                                                 \
-                BOOST_TYPE_ERASURE_MEMBER_QUALIFIED_ID(qual_name, N)(),                         \
-                *this BOOST_TYPE_ERASURE_MEMBER_FORWARD_REBIND(N));                             \
-        }                                                                                       \
-    };                                                                                          \
-    }}
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_MEMBER_I(namespace_name, concept_name, member, N)\
-    BOOST_TYPE_ERASURE_MEMBER_II(namespace_name, concept_name, member, N)
-
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/operators.hpp b/contrib/restricted/boost/boost/type_erasure/operators.hpp
deleted file mode 100644
index 059f41e091..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/operators.hpp
+++ /dev/null
@@ -1,544 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_OPERATORS_HPP_INCLUDED
-
-#include <iosfwd>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_erasure/detail/const.hpp>
-#include <boost/type_erasure/call.hpp>
-#include <boost/type_erasure/concept_interface.hpp>
-#include <boost/type_erasure/placeholder.hpp>
-#include <boost/type_erasure/concept_of.hpp>
-#include <boost/type_erasure/derived.hpp>
-#include <boost/type_erasure/rebind_any.hpp>
-#include <boost/type_erasure/param.hpp>
-#include <boost/type_erasure/check_match.hpp>
-#include <boost/type_erasure/relaxed.hpp>
-#include <boost/type_erasure/typeid_of.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(name, op)                         \
-    template<class T = _self>                                                       \
-    struct name                                                                     \
-    {                                                                               \
-        static void apply(T& arg) { op arg; }                                       \
-    };                                                                              \
-                                                                                    \
-    template<class T, class Base>                                                   \
-    struct concept_interface<name<T>, Base, T,                                      \
-        typename ::boost::enable_if<                                                \
-            detail::should_be_non_const<T, Base>                                    \
-        >::type                                                                     \
-    > : Base                                                                        \
-    {                                                                               \
-        typedef typename ::boost::type_erasure::derived<Base>::type _derived;       \
-        _derived& operator op()                                                     \
-        {                                                                           \
-            ::boost::type_erasure::call(name<T>(), *this);                          \
-            return static_cast<_derived&>(*this);                                   \
-        }                                                                           \
-        typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int)  \
-        {                                                                           \
-            typename ::boost::type_erasure::rebind_any<Base, T>::type result(       \
-                static_cast<_derived&>(*this));                                     \
-            ::boost::type_erasure::call(name<T>(), *this);                          \
-            return result;                                                          \
-        }                                                                           \
-    };                                                                              \
-                                                                                    \
-    template<class T, class Base>                                                   \
-    struct concept_interface<name<T>, Base, T,                                      \
-        typename ::boost::enable_if<                                                \
-            detail::should_be_const<T, Base>                                        \
-        >::type                                                                     \
-    > : Base                                                                        \
-    {                                                                               \
-        typedef typename ::boost::type_erasure::derived<Base>::type _derived;       \
-        const _derived& operator op() const                                         \
-        {                                                                           \
-            ::boost::type_erasure::call(name<T>(), *this);                          \
-            return static_cast<const _derived&>(*this);                             \
-        }                                                                           \
-        typename ::boost::type_erasure::rebind_any<Base, T>::type operator op(int) const \
-        {                                                                           \
-            typename ::boost::type_erasure::rebind_any<Base, T>::type result(       \
-                static_cast<const _derived&>(*this));                               \
-            ::boost::type_erasure::call(name<T>(), *this);                          \
-            return result;                                                          \
-        }                                                                           \
-    };
-
-/**
- * The @ref incrementable concept allow pre and
- * post increment on an @ref any.  The contained
- * type must provide a pre-increment operator.
- */
-BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(incrementable, ++)
-/**
- * The @ref decrementable concept allow pre and
- * post decrement on an @ref any.  The contained
- * type must provide a pre-decrement operator.
- */
-BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR(decrementable, --)
-
-#undef BOOST_TYPE_ERASURE_UNARY_INPLACE_OPERATOR
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_UNARY_OPERATOR(name, op)                                     \
-    template<class T = _self, class R = T>                                              \
-    struct name                                                                         \
-    {                                                                                   \
-        static R apply(const T& arg) { return op arg; }                                 \
-    };                                                                                  \
-                                                                                        \
-    template<class T, class R, class Base>                                              \
-    struct concept_interface<name<T, R>, Base, T> : Base                                \
-    {                                                                                   \
-        typename ::boost::type_erasure::rebind_any<Base, R>::type operator op() const   \
-        {                                                                               \
-            return ::boost::type_erasure::call(name<T, R>(), *this);                    \
-        }                                                                               \
-    };
-
-/**
- * The @ref complementable concept allow use of the bitwise
- * complement operator on an @ref any.
- */
-BOOST_TYPE_ERASURE_UNARY_OPERATOR(complementable, ~)
-/**
- * The @ref negatable concept allow use of the unary
- * minus operator on an @ref any.
- */
-BOOST_TYPE_ERASURE_UNARY_OPERATOR(negatable, -)
-
-#undef BOOST_TYPE_ERASURE_UNARY_OPERATOR
-
-template<class R, class T = _self>
-struct dereferenceable
-{
-    static R apply(const T& arg) { return *arg; }
-};
-
-/// \cond show_operators
-
-template<class R, class T, class Base>
-struct concept_interface<dereferenceable<R, T>, Base, T> : Base
-{
-    typename ::boost::type_erasure::rebind_any<Base, R>::type operator*() const
-    {
-        return ::boost::type_erasure::call(dereferenceable<R, T>(), *this);
-    }
-};
-
-/// \endcond
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_BINARY_OPERATOR(name, op)                        \
-    template<class T = _self, class U = T, class R = T>                     \
-    struct name                                                             \
-    {                                                                       \
-        static R apply(const T& lhs, const U& rhs) { return lhs op rhs; }   \
-    };                                                                      \
-                                                                            \
-    template<class T, class U, class R, class Base>                         \
-    struct concept_interface<name<T, U, R>, Base, T> : Base                 \
-    {                                                                       \
-        friend typename rebind_any<Base, R>::type                           \
-        operator op(const typename derived<Base>::type& lhs,                \
-                    typename as_param<Base, const U&>::type rhs)            \
-        {                                                                   \
-            return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs);  \
-        }                                                                   \
-    };                                                                      \
-                                                                            \
-    template<class T, class U, class R, class Base>                         \
-    struct concept_interface<                                               \
-        name<T, U, R>,                                                      \
-        Base,                                                               \
-        U,                                                                  \
-        typename ::boost::disable_if<                                       \
-            ::boost::type_erasure::is_placeholder<T> >::type                \
-    > : Base                                                                \
-    {                                                                       \
-        friend typename rebind_any<Base, R>::type                           \
-        operator op(const T& lhs,                                           \
-                    const typename derived<Base>::type& rhs)                \
-        {                                                                   \
-            return ::boost::type_erasure::call(name<T, U, R>(), lhs, rhs);  \
-        }                                                                   \
-    };
-
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(addable, +)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(subtractable, -)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(multipliable, *)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(dividable, /)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(modable, %)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(left_shiftable, <<)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(right_shiftable, >>)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitandable, &)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitorable, |)
-BOOST_TYPE_ERASURE_BINARY_OPERATOR(bitxorable, ^)
-
-#undef BOOST_TYPE_ERASURE_BINARY_OPERATOR
-
-/** INTERNAL ONLY */
-#define BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(name, op)                    \
-    template<class T = _self, class U = T>                                  \
-    struct name                                                             \
-    {                                                                       \
-        static void apply(T& lhs, const U& rhs) { lhs op rhs; }             \
-    };                                                                      \
-                                                                            \
-    template<class T, class U, class Base>                                  \
-    struct concept_interface<name<T, U>, Base, T,                           \
-        typename ::boost::disable_if<                                       \
-            ::boost::is_same<                                               \
-                typename ::boost::type_erasure::placeholder_of<Base>::type, \
-                const T&                                                    \
-            >                                                               \
-        >::type                                                             \
-    > : Base                                                                \
-    {                                                                       \
-        friend typename detail::non_const_this_param<Base>::type&           \
-        operator op(typename detail::non_const_this_param<Base>::type& lhs, \
-                    typename as_param<Base, const U&>::type rhs)            \
-        {                                                                   \
-            ::boost::type_erasure::call(name<T, U>(),lhs, rhs);             \
-            return lhs;                                                     \
-        }                                                                   \
-    };                                                                      \
-                                                                            \
-    template<class T, class U, class Base>                                  \
-    struct concept_interface<                                               \
-        name<T, U>,                                                         \
-        Base,                                                               \
-        U,                                                                  \
-        typename ::boost::disable_if<                                       \
-            ::boost::type_erasure::is_placeholder<T> >::type                \
-    > : Base                                                                \
-    {                                                                       \
-        friend T&                                                           \
-        operator op(T& lhs, const typename derived<Base>::type& rhs)        \
-        {                                                                   \
-            ::boost::type_erasure::call(name<T, U>(),lhs, rhs);             \
-            return lhs;                                                     \
-        }                                                                   \
-    };
-
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(add_assignable, +=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(subtract_assignable, -=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(multiply_assignable, *=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(divide_assignable, /=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(mod_assignable, %=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(left_shift_assignable, <<=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(right_shift_assignable, >>=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitand_assignable, &=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitor_assignable, |=)
-BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR(bitxor_assignable, ^=)
-
-#undef BOOST_TYPE_ERASURE_ASSIGNMENT_OPERATOR
-
-template<class T = _self, class U = T>
-struct equality_comparable
-{
-    static bool apply(const T& lhs, const U& rhs) { return lhs == rhs; }
-};
-
-/// \cond show_operators
-
-template<class T, class U, class Base>
-struct concept_interface<equality_comparable<T, U>, Base, T> : Base
-{
-    friend bool operator==(const typename derived<Base>::type& lhs,
-                           typename as_param<Base, const U&>::type rhs)
-    {
-        if(::boost::type_erasure::check_match(equality_comparable<T, U>(), lhs, rhs)) {
-            return ::boost::type_erasure::unchecked_call(equality_comparable<T, U>(), lhs, rhs);
-        } else {
-            return false;
-        }
-    }
-    friend bool operator!=(const typename derived<Base>::type& lhs,
-                           typename as_param<Base, const U&>::type rhs)
-    {
-        return !(lhs == rhs);
-    }
-};
-
-template<class T, class U, class Base>
-struct concept_interface<
-    equality_comparable<T, U>,
-    Base,
-    U,
-    typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type
-> : Base
-{
-    friend bool operator==(const T& lhs, const typename derived<Base>::type& rhs)
-    {
-        return ::boost::type_erasure::call(equality_comparable<T, U>(), lhs, rhs);
-    }
-    friend bool operator!=(const T& lhs, const typename derived<Base>::type& rhs)
-    {
-        return !(lhs == rhs);
-    }
-};
-
-/// \endcond
-
-template<class T = _self, class U = T>
-struct less_than_comparable
-{
-    static bool apply(const T& lhs, const U& rhs) { return lhs < rhs; }
-};
-
-namespace detail {
-
-template<class F, class T, class U>
-bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::true_)
-{
-    if(::boost::type_erasure::check_match(f, lhs, rhs)) {
-        return ::boost::type_erasure::unchecked_call(f, lhs, rhs);
-    } else {
-        return ::boost::type_erasure::typeid_of(
-            static_cast<const typename derived<T>::type&>(lhs)
-        ).before(
-            ::boost::type_erasure::typeid_of(
-                static_cast<const typename derived<U>::type&>(rhs)
-            )
-        ) != false;
-    }
-}
-
-template<class F, class T, class U>
-bool less_impl(const F& f, const T& lhs, const U& rhs, ::boost::mpl::false_)
-{
-    return ::boost::type_erasure::call(f, lhs, rhs);
-}
-
-}
-
-/// \cond show_operators
-
-template<class T, class Base>
-struct concept_interface<less_than_comparable<T, T>, Base, T> : Base
-{
-    friend bool operator<(const typename derived<Base>::type& lhs,
-                          typename as_param<Base, const T&>::type rhs)
-    {
-        return ::boost::type_erasure::detail::less_impl(
-            less_than_comparable<T, T>(),
-            lhs, rhs,
-            ::boost::type_erasure::is_relaxed<
-                typename ::boost::type_erasure::concept_of<Base>::type>());
-    }
-    friend bool operator>=(const typename derived<Base>::type& lhs,
-                           typename as_param<Base, const T&>::type rhs)
-    {
-        return !(lhs < rhs);
-    }
-    friend bool operator>(typename as_param<Base, const T&>::type lhs,
-                          const typename derived<Base>::type& rhs)
-    {
-        return rhs < lhs;
-    }
-    friend bool operator<=(typename as_param<Base, const T&>::type lhs,
-                          const typename derived<Base>::type& rhs)
-    {
-        return !(rhs < lhs);
-    }
-};
-
-template<class T, class U, class Base>
-struct concept_interface<less_than_comparable<T, U>, Base, T> : Base
-{
-    friend bool operator<(const typename derived<Base>::type& lhs,
-                          typename as_param<Base, const U&>::type rhs)
-    {
-        return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs);
-    }
-    friend bool operator>=(const typename derived<Base>::type& lhs,
-                           typename as_param<Base, const U&>::type rhs)
-    {
-        return !(lhs < rhs);
-    }
-    friend bool operator>(typename as_param<Base, const U&>::type lhs,
-                          const typename derived<Base>::type& rhs)
-    {
-        return rhs < lhs;
-    }
-    friend bool operator<=(typename as_param<Base, const U&>::type lhs,
-                          const typename derived<Base>::type& rhs)
-    {
-        return !(rhs < lhs);
-    }
-};
-
-template<class T, class U, class Base>
-struct concept_interface<
-    less_than_comparable<T, U>,
-    Base,
-    U,
-    typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<T> >::type
-> : Base
-{
-    friend bool operator<(const T& lhs, const typename derived<Base>::type& rhs)
-    {
-        return ::boost::type_erasure::call(less_than_comparable<T, U>(), lhs, rhs);
-    }
-    friend bool operator>=(const T& lhs, const typename derived<Base>::type& rhs)
-    {
-        return !(lhs < rhs);
-    }
-    friend bool operator>(const typename derived<Base>::type& lhs, const T& rhs)
-    {
-        return rhs < lhs;
-    }
-    friend bool operator<=(const typename derived<Base>::type& lhs, const T& rhs)
-    {
-        return !(rhs < lhs);
-    }
-};
-
-/// \endcond
-
-template<class R, class T = _self, class N = std::ptrdiff_t>
-struct subscriptable
-{
-    static R apply(T& arg, const N& index) { return arg[index]; }
-};
-
-/// \cond show_operators
-
-template<class R, class T, class N, class Base>
-struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type,
-    typename ::boost::enable_if<
-        ::boost::type_erasure::detail::should_be_non_const<T, Base>
-    >::type
-> : Base
-{
-    typename ::boost::type_erasure::rebind_any<Base, R>::type operator[](
-        typename ::boost::type_erasure::as_param<Base, const N&>::type index)
-    {
-        return ::boost::type_erasure::call(subscriptable<R, T, N>(), *this, index);
-    }
-};
-
-template<class R, class T, class N, class Base>
-struct concept_interface<subscriptable<R, T, N>, Base, typename ::boost::remove_const<T>::type,
-    typename ::boost::enable_if<
-        ::boost::type_erasure::detail::should_be_const<T, Base>
-    >::type
-> : Base
-{
-    typename ::boost::type_erasure::rebind_any<Base, R>::type operator[](
-        typename ::boost::type_erasure::as_param<Base, const N&>::type index) const
-    {
-        return ::boost::type_erasure::call(subscriptable<R, const T, N>(), *this, index);
-    }
-};
-
-/// \endcond
-
-/**
- * The @ref ostreamable concept allows an @ref any to be
- * written to a @c std::ostream.
- */
-template<class Os = std::ostream, class T = _self>
-struct ostreamable
-{
-    static void apply(Os& out, const T& arg) { out << arg; }
-};
-
-/// \cond show_operators
-
-template<class Base, class Os, class T>
-struct concept_interface<ostreamable<Os, T>, Base, Os> : Base
-{
-    friend typename detail::non_const_this_param<Base>::type&
-    operator<<(typename detail::non_const_this_param<Base>::type& lhs,
-               typename ::boost::type_erasure::as_param<Base, const T&>::type rhs)
-    {
-        ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs);
-        return lhs;
-    }
-};
-
-template<class Base, class Os, class T>
-struct concept_interface<
-    ostreamable<Os, T>,
-    Base,
-    T,
-    typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Os> >::type
-> : Base
-{
-    friend Os&
-    operator<<(Os& lhs,
-               const typename ::boost::type_erasure::derived<Base>::type& rhs)
-    {
-        ::boost::type_erasure::call(ostreamable<Os, T>(), lhs, rhs);
-        return lhs;
-    }
-};
-
-/// \endcond
-
-/**
- * The @ref istreamable concept allows an @ref any to be
- * read from a @c std::istream.
- */
-template<class Is = std::istream, class T = _self>
-struct istreamable
-{
-    static void apply(Is& out, T& arg) { out >> arg; }
-};
-
-/// \cond show_operators
-
-
-template<class Base, class Is, class T>
-struct concept_interface<istreamable<Is, T>, Base, Is> : Base
-{
-    friend typename detail::non_const_this_param<Base>::type&
-    operator>>(typename detail::non_const_this_param<Base>::type& lhs,
-               typename ::boost::type_erasure::as_param<Base, T&>::type rhs)
-    {
-        ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs);
-        return lhs;
-    }
-};
-
-template<class Base, class Is, class T>
-struct concept_interface<
-    istreamable<Is, T>,
-    Base,
-    T,
-    typename ::boost::disable_if< ::boost::type_erasure::is_placeholder<Is> >::type
-> : Base
-{
-    friend Is&
-    operator>>(Is& lhs,
-               typename ::boost::type_erasure::derived<Base>::type& rhs)
-    {
-        ::boost::type_erasure::call(istreamable<Is, T>(), lhs, rhs);
-        return lhs;
-    }
-};
-
-/// \endcond
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/same_type.hpp b/contrib/restricted/boost/boost/type_erasure/same_type.hpp
deleted file mode 100644
index c2cf7a324d..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/same_type.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_SAME_TYPE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_SAME_TYPE_HPP_INCLUDED
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * A built in concept that indicates that two
- * types are the same.  Either T or U or both
- * can be placeholders.
- *
- * \warning Any number of instances of @ref deduced
- * can be connected with @ref same_type, but there
- * should be at most one regular placeholder in
- * the group. same_type<_a, _b> is not allowed.
- * The reason for this is that the library needs
- * to normalize all the placeholders, and in this
- * context there is no way to decide whether to
- * use @ref _a or @ref _b.
- */
-template<class T, class U>
-struct same_type {};
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/tuple.hpp b/contrib/restricted/boost/boost/type_erasure/tuple.hpp
deleted file mode 100644
index 945dcdafe4..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/tuple.hpp
+++ /dev/null
@@ -1,659 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011-2012 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#if !defined(BOOST_PP_IS_ITERATING)
-
-#ifndef BOOST_TYPE_ERASURE_TUPLE_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_TUPLE_HPP_INCLUDED
-
-#include <boost/config.hpp>
-
-
-#ifdef BOOST_TYPE_ERASURE_DOXYGEN
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * @ref tuple is a Boost.Fusion Random Access Sequence containing
- * @ref any "anys". @c Concept specifies the \Concept for each
- * of the elements.  The remaining arguments must be (possibly const
- * and/or reference qualified) placeholders, which are the
- * @ref placeholder "placeholders" of the elements.
- */
-template<class Concept, class... T>
-class tuple
-{
-public:
-    /**
-     * Constructs a tuple.  Each element of @c args will
-     * be used to initialize the corresponding @ref any member.
-     * The @ref binding for the tuple elements is determined
-     * by mapping the placeholders in @c T to the corresponding
-     * types in @c U.
-     */
-    template<class... U>
-    explicit tuple(U&&... args);
-};
-
-/**
- * Returns the Nth @ref any in the tuple.
- */
-template<int N, class Concept, class... T>
-any<Concept, TN>& get(tuple<Concept, T...>& arg);
-/** \overload */
-template<int N, class Concept, class... T>
-const any<Concept, TN>& get(const tuple<Concept, T...>& arg);
-
-}
-}
-
-#elif !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/map.hpp>
-#include <boost/mpl/insert.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/fusion/include/category_of.hpp>
-#include <boost/fusion/include/iterator_facade.hpp>
-#include <boost/fusion/include/sequence_facade.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/config.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-template<class Concept, class... T>
-struct cons;
-
-template<class Concept>
-struct cons<Concept>
-{
-    template<class Binding>
-    cons(const Binding&) {}
-};
-
-template<class Concept, class T0, class... T>
-struct cons<Concept, T0, T...>
-{
-    typedef any<Concept, T0> value_type;
-    typedef cons<Concept, T...> rest_type;
-    template<class Binding, class U0, class... U>
-    cons(const Binding& b, U0&& u0, U&&... u)
-      : value(std::forward<U0>(u0), b),
-        rest(b, std::forward<U>(u)...)
-    {}
-    any<Concept, T0> value;
-    cons<Concept, T...> rest;
-};
-
-namespace detail {
-
-template<int N, class Cons>
-struct cons_advance
-{
-    typedef typename cons_advance<N-1, Cons>::type::rest_type type;
-    static const type& call(const Cons& c)
-    {
-        return cons_advance<N-1, Cons>::call(c).rest;
-    }
-};
-
-template<class Cons>
-struct cons_advance<0, Cons>
-{
-    typedef Cons type;
-    static const type& call(const Cons& c)
-    {
-        return c;
-    }
-};
-
-template<class... T>
-struct make_map;
-
-template<class T0, class... T>
-struct make_map<T0, T...>
-{
-    typedef typename ::boost::mpl::insert<
-        typename ::boost::type_erasure::detail::make_map<T...>::type,
-        T0
-    >::type type;
-};
-
-template<>
-struct make_map<>
-{
-    typedef ::boost::mpl::map0<> type;
-};
-
-}
-
-/** INTERNAL ONLY */
-template<class Tuple, int N>
-class tuple_iterator :
-    public ::boost::fusion::iterator_facade<
-        tuple_iterator<Tuple, N>,
-        ::boost::fusion::random_access_traversal_tag
-    >
-{
-public:
-    typedef ::boost::mpl::int_<N> index;
-    explicit tuple_iterator(Tuple& t_arg) : t(&t_arg) {}
-    template<class It>
-    struct value_of
-    {
-        typedef typename Tuple::template value_at<Tuple, mpl::int_<N> >::type type;
-    };
-    template<class It>
-    struct deref
-    {
-        typedef typename Tuple::template at<Tuple, mpl::int_<N> >::type type;
-        static type call(It it)
-        {
-            return Tuple::template at<Tuple, mpl::int_<N> >::call(*it.t);
-        }
-    };
-    template<class It, class M>
-    struct advance
-    {
-        typedef tuple_iterator<Tuple, (It::index::value+M::value)> type;
-        static type call(It it) { return type(*it.t); }
-    };
-    template<class It>
-    struct next : advance<It, ::boost::mpl::int_<1> > {};
-    template<class It>
-    struct prior : advance<It, ::boost::mpl::int_<-1> > {};
-    template<class It1, class It2>
-    struct distance
-    {
-        typedef typename ::boost::mpl::minus<
-            typename It2::index,
-            typename It1::index
-        >::type type;
-        static type call(It1, It2) { return type(); }
-    };
-private:
-    Tuple* t;
-};
-
-template<class Concept, class... T>
-class tuple :
-    public ::boost::fusion::sequence_facade<
-        ::boost::type_erasure::tuple<Concept, T...>,
-        ::boost::fusion::forward_traversal_tag
-    >
-{
-public:
-    template<class... U>
-    explicit tuple(U&&... args)
-      : impl(
-            ::boost::type_erasure::make_binding<
-                typename ::boost::type_erasure::detail::make_map<
-                    ::boost::mpl::pair<
-                        typename ::boost::remove_const<
-                            typename ::boost::remove_reference<T>::type
-                        >::type,
-                        typename ::boost::remove_const<
-                            typename ::boost::remove_reference<U>::type
-                        >::type
-                    >...
-                >::type
-            >(),
-            std::forward<U>(args)...)
-    {}
-
-    template<class Seq>
-    struct begin
-    {
-        typedef ::boost::type_erasure::tuple_iterator<
-            Seq,
-            0
-        > type;
-        static type call(Seq& seq) { return type(seq); }
-    };
-    template<class Seq>
-    struct end
-    {
-        typedef ::boost::type_erasure::tuple_iterator<
-            Seq,
-            sizeof...(T)
-        > type;
-        static type call(Seq& seq) { return type(seq); }
-    };
-    template<class Seq>
-    struct size
-    {
-        typedef ::boost::mpl::int_<sizeof...(T)> type;
-        static type call(Seq& seq) { return type(); }
-    };
-    template<class Seq>
-    struct empty
-    {
-        typedef ::boost::mpl::bool_<sizeof...(T) == 0> type;
-        static type call(Seq& seq) { return type(); }
-    };
-    template<class Seq, class N>
-    struct at
-    {
-        typedef typename ::boost::type_erasure::detail::cons_advance<
-            N::value,
-            ::boost::type_erasure::cons<Concept, T...>
-        >::type::value_type value_type;
-        typedef typename ::boost::mpl::if_< ::boost::is_const<Seq>,
-            const value_type&,
-            value_type&
-        >::type type;
-        static type call(Seq& seq)
-        {
-            return const_cast<type>(
-                ::boost::type_erasure::detail::cons_advance<
-                    N::value,
-                    ::boost::type_erasure::cons<Concept, T...>
-                >::call(seq.impl).value
-            );
-        }
-    };
-    template<class Seq, class N>
-    struct value_at
-    {
-        typedef typename ::boost::type_erasure::detail::cons_advance<
-            N::value,
-            ::boost::type_erasure::cons<Concept, T...>
-        >::type::value_type value_type;
-    };
-    ::boost::type_erasure::cons<Concept, T...> impl;
-};
-
-template<int N, class Concept, class... T>
-typename ::boost::type_erasure::detail::cons_advance<
-    N,
-    ::boost::type_erasure::cons<Concept, T...>
->::type::value_type& get(::boost::type_erasure::tuple<Concept, T...>& t)
-{
-    return const_cast<
-        typename ::boost::type_erasure::detail::cons_advance<
-            N,
-            ::boost::type_erasure::cons<Concept, T...>
-        >::type::value_type&
-    >(
-        ::boost::type_erasure::detail::cons_advance<N,
-            ::boost::type_erasure::cons<Concept, T...>
-        >::call(t.impl).value
-    );
-}
-
-template<int N, class Concept, class... T>
-const typename ::boost::type_erasure::detail::cons_advance<
-    N,
-    ::boost::type_erasure::cons<Concept, T...>
->::type::value_type& get(const ::boost::type_erasure::tuple<Concept, T...>& t)
-{
-    return ::boost::type_erasure::detail::cons_advance<
-        N,
-        ::boost::type_erasure::cons<Concept, T...>
-    >::call(t.impl).value;
-}
-
-}
-}
-
-#else
-
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/mpl/equal_to.hpp>
-#include <boost/mpl/map.hpp>
-#include <boost/fusion/include/category_of.hpp>
-#include <boost/fusion/include/iterator_facade.hpp>
-#include <boost/fusion/include/sequence_facade.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/iteration/iterate.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/repetition/enum.hpp>
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
-#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/static_binding.hpp>
-#include <boost/type_erasure/config.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/** INTERNAL ONLY */
-struct na {};
-
-namespace detail {
-
-template<int N, class Tuple>
-struct get_impl;
-
-template<class Concept,
-    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-        BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, class T, ::boost::type_erasure::na)>
-struct tuple_storage;
-
-}
-
-/** INTERNAL ONLY */
-template<class Tuple, int N>
-class tuple_iterator :
-    public ::boost::fusion::iterator_facade<
-        tuple_iterator<Tuple, N>,
-        ::boost::fusion::random_access_traversal_tag
-    >
-{
-public:
-    typedef ::boost::mpl::int_<N> index;
-    explicit tuple_iterator(Tuple& t_arg) : t(&t_arg) {}
-    template<class It>
-    struct value_of
-    {
-        typedef typename ::boost::type_erasure::detail::get_impl<
-            It::index::value,
-            Tuple
-        >::value_type type;
-    };
-    template<class It>
-    struct deref :
-        ::boost::type_erasure::detail::get_impl<It::index::value, Tuple>
-    {
-        typedef typename ::boost::type_erasure::detail::get_impl<
-            It::index::value,
-            Tuple
-        >::type type;
-        static type call(It it)
-        {
-            return ::boost::type_erasure::detail::get_impl<
-                It::index::value,
-                Tuple
-            >::call(*it.t);
-        }
-    };
-    template<class It, class M>
-    struct advance
-    {
-        typedef tuple_iterator<Tuple, (It::index::value+M::value)> type;
-        static type call(It it) { return type(*it.t); }
-    };
-    template<class It>
-    struct next : advance<It, ::boost::mpl::int_<1> > {};
-    template<class It>
-    struct prior : advance<It, ::boost::mpl::int_<-1> > {};
-    template<class It1, class It2>
-    struct distance
-    {
-        typedef typename ::boost::mpl::minus<
-            typename It2::index,
-            typename It1::index
-        >::type type;
-        static type call(It1, It2) { return type(); }
-    };
-private:
-    Tuple* t;
-};
-
-/** INTERNAL ONLY */
-template<class Derived>
-struct tuple_base :
-    ::boost::fusion::sequence_facade<
-        Derived,
-        ::boost::fusion::random_access_traversal_tag
-    >
-{
-    template<class Seq>
-    struct begin
-    {
-        typedef ::boost::type_erasure::tuple_iterator<Seq, 0> type;
-        static type call(Seq& seq) { return type(seq); }
-    };
-    template<class Seq>
-    struct end
-    {
-        typedef ::boost::type_erasure::tuple_iterator<
-            Seq,
-            Seq::tuple_size::value
-        > type;
-        static type call(Seq& seq) { return type(seq); }
-    };
-    template<class Seq>
-    struct size
-    {
-        typedef typename Seq::tuple_size type;
-        static type call(Seq& seq) { return type(); }
-    };
-    template<class Seq>
-    struct empty
-    {
-        typedef typename boost::mpl::equal_to<
-            typename Seq::tuple_size,
-            boost::mpl::int_<0>
-        >::type type;
-        static type call(Seq& seq) { return type(); }
-    };
-    template<class Seq, class N>
-    struct at : ::boost::type_erasure::detail::get_impl<N::value, Seq> {};
-    template<class Seq, class N>
-    struct value_at
-    {
-        typedef typename ::boost::type_erasure::detail::get_impl<
-            N::value,
-            Seq
-        >::value_type type;
-    };
-};
-
-template<class Concept,
-    BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(
-        BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, class T, ::boost::type_erasure::na)>
-class tuple;
-
-template<
-    int N,
-    class Concept
-    BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, class T)
->
-typename detail::get_impl<
-    N,
-    tuple<
-        Concept
-        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-    >
->::type get(
-    tuple<
-        Concept
-        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-    >& arg)
-{
-    return detail::get_impl<
-        N,
-        tuple<
-            Concept
-            BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-        >
-    >::call(arg);
-}
-
-template<
-    int N,
-    class Concept
-    BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, class T)
->
-typename detail::get_impl<
-    N,
-    const tuple<
-        Concept
-        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-    >
->::type get(
-    const tuple<
-        Concept
-        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-    >& arg)
-{
-    return detail::get_impl<
-        N,
-        const tuple<
-            Concept
-            BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE, T)
-        >
-    >::call(arg);
-}
-    
-/** INTERNAL ONLY */
-#define BOOST_PP_FILENAME_1 <boost/type_erasure/tuple.hpp>
-/** INTERNAL ONLY */
-#define BOOST_PP_ITERATION_LIMITS (0, BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE)
-#include BOOST_PP_ITERATE()
-
-}
-}
-
-#endif
-
-#endif
-
-#else
-
-#define N BOOST_PP_ITERATION()
-
-#define BOOST_TYPE_ERASURE_TAG_TYPEDEF(z, n, data)                          \
-    typedef BOOST_PP_CAT(T, n) BOOST_PP_CAT(tag_type, n);                   \
-    typedef typename ::boost::remove_reference<BOOST_PP_CAT(T, n)>::type    \
-        BOOST_PP_CAT(tag, n);
-
-#define BOOST_TYPE_ERASURE_PAIR(z, n, data) \
-    ::boost::mpl::pair<BOOST_PP_CAT(tag, n), BOOST_PP_CAT(U, n)>
-
-#define BOOST_TYPE_ERASURE_CONSTRUCT(z, n, data)\
-    BOOST_PP_CAT(t, n)(BOOST_PP_CAT(u, n), table)
-
-#define BOOST_TYPE_ERASURE_TUPLE_MEMBER(z, n, data)\
-    ::boost::type_erasure::any<Concept, BOOST_PP_CAT(T, n)> BOOST_PP_CAT(t, n);
-
-#if N == 1
-#define BOOST_TYPE_ERASURE_EXPLICIT explicit
-#else
-#define BOOST_TYPE_ERASURE_EXPLICIT
-#endif
-
-namespace detail {
-    
-template<class Concept BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-struct tuple_storage
-#if N != BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE
-    <Concept BOOST_PP_ENUM_TRAILING_PARAMS(N, T)>
-#endif
-{
-#if N
-    template<class Table BOOST_PP_ENUM_TRAILING_PARAMS(N, class U)>
-    tuple_storage(
-        const Table& table BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
-        :
-        BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_CONSTRUCT, ~) {}
-#else
-    template<class Table>
-    explicit tuple_storage(const Table&) {}
-#endif
-    BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_TUPLE_MEMBER, `)
-};
-
-#if N != BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE
-
-template<class Tuple>
-struct get_impl<N, Tuple>
-{
-    typedef any<
-        typename Tuple::concept_type,
-        typename Tuple::BOOST_PP_CAT(tag_type, N)
-    > value_type;
-    typedef value_type& type;
-    static type call(Tuple& arg)
-    { return arg.impl.BOOST_PP_CAT(t, N); }
-};
-
-template<class Tuple>
-struct get_impl<N, const Tuple>
-{
-    typedef any<
-        typename Tuple::concept_type,
-        typename Tuple::BOOST_PP_CAT(tag_type, N)
-    > value_type;
-    typedef const value_type& type;
-    static type call(const Tuple& arg)
-    { return arg.impl.BOOST_PP_CAT(t, N); }
-};
-
-#endif
-
-}
-
-template<class Concept BOOST_PP_ENUM_TRAILING_PARAMS(N, class T)>
-class tuple 
-#if N != BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE
-    <Concept BOOST_PP_ENUM_TRAILING_PARAMS(N, T)>
-#endif
-    : public tuple_base<tuple<Concept BOOST_PP_ENUM_TRAILING_PARAMS(N, T)> >
-{
-    typedef Concept concept_type;
-    BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_TAG_TYPEDEF, ~)
-public:
-    typedef ::boost::mpl::int_<N> tuple_size;
-#if N
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-#endif
-    BOOST_TYPE_ERASURE_EXPLICIT
-    tuple(BOOST_PP_ENUM_BINARY_PARAMS(N, U, &u)) :
-        impl(
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map<
-                    BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_PAIR, ~)
-                >
-            >()
-            BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-        )
-    {}
-#if N
-    template<BOOST_PP_ENUM_PARAMS(N, class U)>
-    BOOST_TYPE_ERASURE_EXPLICIT 
-    tuple(BOOST_PP_ENUM_BINARY_PARAMS(N, const U, &u)) :
-        impl(
-            ::boost::type_erasure::make_binding<
-                ::boost::mpl::map<
-                    BOOST_PP_ENUM(N, BOOST_TYPE_ERASURE_PAIR, ~)
-                >
-            >()
-            BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
-        )
-    {}
-#endif
-private:
-    template<int M, class Tuple>
-    friend struct ::boost::type_erasure::detail::get_impl;
-    ::boost::type_erasure::detail::tuple_storage<
-        Concept
-        BOOST_PP_ENUM_TRAILING_PARAMS(N, T)
-    > impl;
-};
-
-#undef BOOST_TYPE_ERASURE_EXPLICIT
-#undef BOOST_TYPE_ERASURE_TUPLE_MEMBER
-#undef BOOST_TYPE_ERASURE_CONSTRUCT
-#undef BOOST_TYPE_ERASURE_PAIR
-#undef BOOST_TYPE_ERASURE_TAG_TYPEDEF
-#undef N
-
-#endif
diff --git a/contrib/restricted/boost/boost/type_erasure/typeid_of.hpp b/contrib/restricted/boost/boost/type_erasure/typeid_of.hpp
deleted file mode 100644
index 5606883c6b..0000000000
--- a/contrib/restricted/boost/boost/type_erasure/typeid_of.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// Boost.TypeErasure library
-//
-// Copyright 2011 Steven Watanabe
-//
-// 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)
-//
-// $Id$
-
-#ifndef BOOST_TYPE_ERASURE_TYPEID_OF_HPP_INCLUDED
-#define BOOST_TYPE_ERASURE_TYPEID_OF_HPP_INCLUDED
-
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_erasure/detail/access.hpp>
-#include <boost/type_erasure/any.hpp>
-#include <boost/type_erasure/binding.hpp>
-
-namespace boost {
-namespace type_erasure {
-
-/**
- * The first form returns the type currently stored in an @ref any.
- *
- * The second form returns the type corresponding to a
- * placeholder in @c binding.
- *
- * \pre @c Concept includes @ref typeid_ "typeid_<T>".
- * \pre @c T is a non-reference, CV-unqualified @ref placeholder.
- */
-template<class Concept, class T>
-const std::type_info& typeid_of(const any<Concept, T>& arg)
-{
-    return ::boost::type_erasure::detail::access::table(arg).template find<
-        ::boost::type_erasure::typeid_<
-            typename ::boost::remove_cv<
-                typename ::boost::remove_reference<T>::type
-            >::type
-        >
-    >()();
-}
-
-#ifndef BOOST_TYPE_ERASURE_DOXYGEN
-template<class Concept, class T>
-const std::type_info& typeid_of(const param<Concept, T>& arg)
-{
-    return ::boost::type_erasure::detail::access::table(arg).template find<
-        ::boost::type_erasure::typeid_<
-            typename ::boost::remove_cv<
-                typename ::boost::remove_reference<T>::type
-            >::type
-        >
-    >()();
-}
-#endif
-
-/**
- * \overload
- */
-template<class T, class Concept>
-const std::type_info& typeid_of(const binding<Concept>& binding_arg)
-{
-    return binding_arg.template find< ::boost::type_erasure::typeid_<T> >()();
-}
-
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp
new file mode 100644
index 0000000000..06c8e48997
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/algorithm.hpp
@@ -0,0 +1,1306 @@
+#ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
+#define BOOST_MP11_ALGORITHM_HPP_INCLUDED
+
+//  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/mp11/list.hpp>
+#include <boost/mp11/set.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/detail/mp_count.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/mp_map_find.hpp>
+#include <boost/mp11/detail/mp_with_index.hpp>
+#include <boost/mp11/detail/mp_fold.hpp>
+#include <boost/mp11/detail/mp_min_element.hpp>
+#include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_remove_if.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <boost/mp11/integer_sequence.hpp>
+#include <type_traits>
+#include <utility>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_transform<F, L...>
+namespace detail
+{
+
+template<template<class...> class F, class... L> struct mp_transform_impl
+{
+};
+
+template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    template<class... U> struct f { using type = F<U...>; };
+
+    using type = L<typename f<T>::type...>;
+
+#else
+
+    using type = L<F<T>...>;
+
+#endif
+};
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    template<class... U> struct f { using type = F<U...>; };
+
+    using type = L1<typename f<T1, T2>::type...>;
+
+#else
+
+    using type = L1<F<T1,T2>...>;
+
+#endif
+};
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    template<class... U> struct f { using type = F<U...>; };
+
+    using type = L1<typename f<T1, T2, T3>::type...>;
+
+#else
+
+    using type = L1<F<T1,T2,T3>...>;
+
+#endif
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<class... L> using mp_same_size_1 = mp_same<mp_size<L>...>;
+template<class... L> struct mp_same_size_2: mp_defer<mp_same_size_1, L...> {};
+
+#endif
+
+struct list_size_mismatch
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> struct mp_transform_cuda_workaround
+{
+    using type = mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, == 1900 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<template<class...> class F, class... L> using mp_transform = typename mp_if<typename detail::mp_same_size_2<L...>::type, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... L> using mp_transform = typename detail::mp_transform_cuda_workaround< F, L...>::type::type;
+
+#else
+
+template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;
+
+#endif
+
+#endif
+
+template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;
+
+namespace detail
+{
+
+template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
+{
+    using A1 = L1<mp_list<T1, T2, T3, T4>...>;
+
+    template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;
+
+    using A2 = mp_fold<mp_list<L...>, A1, _f>;
+
+    template<class T> using _g = mp_apply<F, T>;
+
+    using type = mp_transform<_g, A2>;
+};
+
+} // namespace detail
+
+// mp_transform_if<P, F, L...>
+namespace detail
+{
+
+template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
+{
+    // the stupid quote-unquote dance avoids "pack expansion used as argument for non-pack parameter of alias template"
+
+    using Qp = mp_quote<P>;
+    using Qf = mp_quote<F>;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    template<class... U> struct _f_ { using type = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>; };
+    template<class... U> using _f = typename _f_<U...>::type;
+
+#else
+
+    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;
+
+#endif
+
+    using type = mp_transform<_f, L...>;
+};
+
+} // namespace detail
+
+template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
+template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;
+
+// mp_filter<P, L...>
+namespace detail
+{
+
+template<template<class...> class P, class L1, class... L> struct mp_filter_impl
+{
+    using Qp = mp_quote<P>;
+
+    template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;
+
+    using _t1 = mp_transform<_f, L1, L...>;
+    using _t2 = mp_apply<mp_append, _t1>;
+
+    using type = mp_assign<L1, _t2>;
+};
+
+} // namespace detail
+
+template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
+template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;
+
+// mp_fill<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_fill_impl;
+
+template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
+
+    template<class...> struct _f { using type = V; };
+    using type = L<typename _f<T>::type...>;
+
+#else
+
+    template<class...> using _f = V;
+    using type = L<_f<T>...>;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;
+
+// mp_contains<L, V>
+template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;
+
+// mp_repeat(_c)<L, N>
+namespace detail
+{
+
+template<class L, std::size_t N> struct mp_repeat_c_impl
+{
+    using _l1 = typename mp_repeat_c_impl<L, N/2>::type;
+    using _l2 = typename mp_repeat_c_impl<L, N%2>::type;
+
+    using type = mp_append<_l1, _l1, _l2>;
+};
+
+template<class L> struct mp_repeat_c_impl<L, 0>
+{
+    using type = mp_clear<L>;
+};
+
+template<class L> struct mp_repeat_c_impl<L, 1>
+{
+    using type = L;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_repeat_c = typename detail::mp_repeat_c_impl<L, N>::type;
+template<class L, class N> using mp_repeat = typename detail::mp_repeat_c_impl<L, std::size_t{ N::value }>::type;
+
+// mp_product<F, L...>
+namespace detail
+{
+
+template<template<class...> class F, class P, class... L> struct mp_product_impl_2
+{
+};
+
+template<template<class...> class F, class P> struct mp_product_impl_2<F, P>
+{
+    using type = mp_list<mp_rename<P, F>>;
+};
+
+template<template<class...> class F, class P, template<class...> class L1, class... T1, class... L> struct mp_product_impl_2<F, P, L1<T1...>, L...>
+{
+    using type = mp_append<typename mp_product_impl_2<F, mp_push_back<P, T1>, L...>::type...>;
+};
+
+template<template<class...> class F, class... L> struct mp_product_impl
+{
+};
+
+template<template<class...> class F> struct mp_product_impl<F>
+{
+    using type = mp_list< F<> >;
+};
+
+template<template<class...> class F, class L1, class... L> struct mp_product_impl<F, L1, L...>
+{
+    using type = mp_assign<L1, typename mp_product_impl_2<F, mp_list<>, L1, L...>::type>;
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... L> using mp_product = typename detail::mp_product_impl<F, L...>::type;
+template<class Q, class... L> using mp_product_q = typename detail::mp_product_impl<Q::template fn, L...>::type;
+
+// mp_drop(_c)<L, N>
+namespace detail
+{
+
+template<class L, class L2> struct mp_drop_impl;
+
+template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>>
+{
+    template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );
+
+    using R = decltype( f( (mp_identity<T>*)0 ... ) );
+
+    using type = typename R::type;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_drop_c = typename detail::mp_drop_impl<L, mp_repeat_c<mp_list<void>, N>>::type;
+
+template<class L, class N> using mp_drop = typename detail::mp_drop_impl<L, mp_repeat<mp_list<void>, N>>::type;
+
+// mp_from_sequence<S>
+namespace detail
+{
+
+template<class S> struct mp_from_sequence_impl;
+
+template<template<class T, T... I> class S, class U, U... J> struct mp_from_sequence_impl<S<U, J...>>
+{
+    using type = mp_list<std::integral_constant<U, J>...>;
+};
+
+} // namespace detail
+
+template<class S> using mp_from_sequence = typename detail::mp_from_sequence_impl<S>::type;
+
+// mp_iota(_c)<N>
+template<std::size_t N> using mp_iota_c = mp_from_sequence<make_index_sequence<N>>;
+template<class N> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>>;
+
+// mp_at(_c)<L, I>
+namespace detail
+{
+
+template<class L, std::size_t I> struct mp_at_c_impl;
+
+#if defined(BOOST_MP11_HAS_TYPE_PACK_ELEMENT)
+
+template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
+{
+    using type = __type_pack_element<I, T...>;
+};
+
+#else
+
+template<class L, std::size_t I> struct mp_at_c_impl
+{
+    using _map = mp_transform<mp_list, mp_iota<mp_size<L> >, L>;
+    using type = mp_second<mp_map_find<_map, mp_size_t<I> > >;
+};
+
+#endif
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> struct mp_at_c_cuda_workaround
+{
+    using type = mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class L, std::size_t I> using mp_at_c = typename detail::mp_at_c_cuda_workaround< L, I >::type::type;
+
+#else
+
+template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;
+
+#endif
+
+template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;
+
+// mp_take(_c)<L, N>
+namespace detail
+{
+
+template<std::size_t N, class L, class E = void> struct mp_take_c_impl
+{
+};
+
+template<template<class...> class L, class... T>
+struct mp_take_c_impl<0, L<T...>>
+{
+    using type = L<>;
+};
+
+template<template<class...> class L, class T1, class... T>
+struct mp_take_c_impl<1, L<T1, T...>>
+{
+    using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class... T>
+struct mp_take_c_impl<2, L<T1, T2, T...>>
+{
+    using type = L<T1, T2>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class... T>
+struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
+{
+    using type = L<T1, T2, T3>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
+struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
+{
+    using type = L<T1, T2, T3, T4>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
+struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
+{
+    using type = L<T1, T2, T3, T4, T5>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
+struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
+{
+    using type = L<T1, T2, T3, T4, T5, T6>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
+struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
+{
+    using type = L<T1, T2, T3, T4, T5, T6, T7>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
+struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
+{
+    using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
+struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
+{
+    using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
+struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
+{
+    using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
+};
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_take_c = typename detail::mp_take_c_impl<N, L>::type;
+template<class L, class N> using mp_take = typename detail::mp_take_c_impl<std::size_t{ N::value }, L>::type;
+
+// mp_back<L>
+template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;
+
+// mp_pop_back<L>
+template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;
+
+// mp_replace<L, V, W>
+namespace detail
+{
+
+template<class L, class V, class W> struct mp_replace_impl;
+
+template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+    template<class A> struct _f { using type = mp_if<std::is_same<A, V>, W, A>; };
+    using type = L<typename _f<T>::type...>;
+#else
+    template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
+    using type = L<_f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V, class W> using mp_replace = typename detail::mp_replace_impl<L, V, W>::type;
+
+// mp_replace_if<L, P, W>
+namespace detail
+{
+
+template<class L, template<class...> class P, class W> struct mp_replace_if_impl;
+
+template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+    template<class U> struct _f { using type = mp_if<P<U>, W, U>; };
+    using type = L<typename _f<T>::type...>;
+#else
+    template<class U> using _f = mp_if<P<U>, W, U>;
+    using type = L<_f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
+template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;
+
+// mp_copy_if<L, P>
+//   in detail/mp_copy_if.hpp
+
+// mp_remove<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_remove_impl;
+
+template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+    template<class U> struct _f { using type = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>; };
+    using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+    template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
+    using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;
+
+// mp_remove_if<L, P>
+//   in detail/mp_remove_if.hpp
+
+// mp_flatten<L, L2 = mp_clear<L>>
+namespace detail
+{
+
+template<class L2> struct mp_flatten_impl
+{
+    template<class T> using fn = mp_if<mp_similar<L2, T>, T, mp_list<T>>;
+};
+
+} // namespace detail
+
+template<class L, class L2 = mp_clear<L>> using mp_flatten = mp_apply<mp_append, mp_push_front<mp_transform_q<detail::mp_flatten_impl<L2>, L>, mp_clear<L>>>;
+
+// mp_partition<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_partition_impl;
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
+{
+    using type = L<mp_copy_if<L<T...>, P>, mp_remove_if<L<T...>, P>>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
+template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;
+
+// mp_sort<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_sort_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_sort_impl<L<T...>, P>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = L<>;
+};
+
+#else
+
+template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
+{
+    using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
+{
+    using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
+{
+    template<class U> using F = P<U, T1>;
+
+    using part = mp_partition<L<T...>, F>;
+
+    using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
+    using S2 = typename mp_sort_impl<mp_second<part>, P>::type;
+
+    using type = mp_append<mp_push_back<S1, T1>, S2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
+template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;
+
+// mp_nth_element(_c)<L, I, P>
+namespace detail
+{
+
+template<class L, std::size_t I, template<class...> class P> struct mp_nth_element_impl;
+
+template<template<class...> class L, class T1, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1>, I, P>
+{
+    static_assert( I == 0, "mp_nth_element index out of range" );
+    using type = T1;
+};
+
+template<template<class...> class L, class T1, class... T, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1, T...>, I, P>
+{
+    static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );
+
+    template<class U> using F = P<U, T1>;
+
+    using part = mp_partition<L<T...>, F>;
+
+    using L1 = mp_first<part>;
+    static std::size_t const N1 = mp_size<L1>::value;
+
+    using L2 = mp_second<part>;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+    struct detail
+    {
+        struct mp_nth_element_impl_cuda_workaround
+        {
+            using type = mp_cond<
+
+                mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
+                mp_bool<(I == N1)>, mp_identity<T1>,
+                mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
+
+            >;
+        };
+    };
+
+    using type = typename detail::mp_nth_element_impl_cuda_workaround::type::type;
+
+#else
+
+    using type = typename mp_cond<
+
+        mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
+        mp_bool<(I == N1)>, mp_identity<T1>,
+        mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>
+
+    >::type;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c = typename detail::mp_nth_element_impl<L, I, P>::type;
+template<class L, class I, template<class...> class P> using mp_nth_element = typename detail::mp_nth_element_impl<L, std::size_t{ I::value }, P>::type;
+template<class L, class I, class Q> using mp_nth_element_q = mp_nth_element<L, I, Q::template fn>;
+
+// mp_find<L, V>
+namespace detail
+{
+
+template<class L, class V> struct mp_find_impl;
+
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+
+struct mp_index_holder
+{
+    std::size_t i_;
+    bool f_;
+};
+
+constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
+{
+    if( v.f_ )
+    {
+        return v;
+    }
+    else if( f )
+    {
+        return { v.i_, true };
+    }
+    else
+    {
+        return { v.i_ + 1, false };
+    }
+}
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+    static constexpr mp_index_holder _v{ 0, false };
+    using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
+{
+    using type = mp_size_t<0>;
+};
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+constexpr std::size_t cx_find_index( bool const * first, bool const * last )
+{
+    std::size_t m = 0;
+
+    while( first != last && !*first )
+    {
+        ++m;
+        ++first;
+    }
+
+    return m;
+}
+
+#else
+
+constexpr std::size_t cx_find_index( bool const * first, bool const * last )
+{
+    return first == last || *first? 0: 1 + cx_find_index( first + 1, last );
+}
+
+#endif
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+    static constexpr bool _v[] = { std::is_same<T, V>::value... };
+    using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
+};
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = mp_size_t<0>;
+};
+
+#else
+
+template<template<class...> class L, class V> struct mp_find_impl<L<>, V>
+{
+    using type = mp_size_t<0>;
+};
+
+#endif
+
+template<template<class...> class L, class... T, class V> struct mp_find_impl<L<V, T...>, V>
+{
+    using type = mp_size_t<0>;
+};
+
+template<template<class...> class L, class T1, class... T, class V> struct mp_find_impl<L<T1, T...>, V>
+{
+    using _r = typename mp_find_impl<mp_list<T...>, V>::type;
+    using type = mp_size_t<1 + _r::value>;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, class V> using mp_find = typename detail::mp_find_impl<L, V>::type;
+
+// mp_find_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_find_if_impl;
+
+#if BOOST_MP11_CLANG && defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+    static constexpr mp_index_holder _v{ 0, false };
+    using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
+{
+    using type = mp_size_t<0>;
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+    static constexpr bool _v[] = { P<T>::value... };
+    using type = mp_size_t< cx_find_index( _v, _v + sizeof...(T) ) >;
+};
+
+#else
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = mp_size_t<0>;
+};
+
+#else
+
+template<template<class...> class L, template<class...> class P> struct mp_find_if_impl<L<>, P>
+{
+    using type = mp_size_t<0>;
+};
+
+#endif
+
+template<class L, template<class...> class P> struct mp_find_if_impl_2
+{
+    using _r = typename mp_find_if_impl<L, P>::type;
+    using type = mp_size_t<1 + _r::value>;
+};
+
+template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_find_if_impl<L<T1, T...>, P>
+{
+    using type = typename mp_if<P<T1>, mp_identity<mp_size_t<0>>, mp_find_if_impl_2<mp_list<T...>, P>>::type;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
+template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;
+
+// mp_reverse<L>
+namespace detail
+{
+
+template<class L> struct mp_reverse_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T> struct mp_reverse_impl<L<T...>>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = L<>;
+};
+
+#else
+
+template<template<class...> class L> struct mp_reverse_impl<L<>>
+{
+    using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1> struct mp_reverse_impl<L<T1>>
+{
+    using type = L<T1>;
+};
+
+template<template<class...> class L, class T1, class T2> struct mp_reverse_impl<L<T1, T2>>
+{
+    using type = L<T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3> struct mp_reverse_impl<L<T1, T2, T3>>
+{
+    using type = L<T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl<L<T1, T2, T3, T4>>
+{
+    using type = L<T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl<L<T1, T2, T3, T4, T5>>
+{
+    using type = L<T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6>>
+{
+    using type = L<T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7>>
+{
+    using type = L<T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>>
+{
+    using type = L<T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>>
+{
+    using type = L<T9, T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>>
+{
+    using type = mp_push_back<typename mp_reverse_impl<L<T...>>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>;
+};
+
+} // namespace detail
+
+template<class L> using mp_reverse = typename detail::mp_reverse_impl<L>::type;
+
+// mp_fold<L, V, F>
+//   in detail/mp_fold.hpp
+
+// mp_reverse_fold<L, V, F>
+namespace detail
+{
+
+template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T...>, V, F>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = V;
+};
+
+#else
+
+template<template<class...> class L, class V, template<class...> class F> struct mp_reverse_fold_impl<L<>, V, F>
+{
+    using type = V;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T...>, V, F>
+{
+    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
+    using type = F<T1, rest>;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
+{
+    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
+    using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
+template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;
+
+// mp_unique<L>
+namespace detail
+{
+
+template<class L> struct mp_unique_impl;
+
+template<template<class...> class L, class... T> struct mp_unique_impl<L<T...>>
+{
+    using type = mp_set_push_back<L<>, T...>;
+};
+
+} // namespace detail
+
+template<class L> using mp_unique = typename detail::mp_unique_impl<L>::type;
+
+// mp_unique_if<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct mp_unique_if_push_back
+{
+    template<class...> struct impl
+    {
+    };
+
+    template<template<class...> class L, class... Ts, class T>
+    struct impl<L<Ts...>, T>
+    {
+        using type = mp_if<mp_any<P<Ts, T>...>, L<Ts...>, L<Ts..., T>>;
+    };
+
+    template<class... T> using fn = typename impl<T...>::type;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P>
+using mp_unique_if = mp_fold_q<L, mp_clear<L>, detail::mp_unique_if_push_back<P>>;
+
+template<class L, class Q> using mp_unique_if_q = mp_unique_if<L, Q::template fn>;
+
+// mp_all_of<L, P>
+template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
+template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;
+
+// mp_none_of<L, P>
+template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
+template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;
+
+// mp_any_of<L, P>
+template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;
+template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;
+
+// mp_replace_at_c<L, I, W>
+namespace detail
+{
+
+template<class L, class I, class W> struct mp_replace_at_impl
+{
+    static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );
+
+    template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
+    template<class T1, class T2> using _f = W;
+
+    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
+};
+
+} // namespace detail
+
+template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
+template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;
+
+//mp_for_each<L>(f)
+namespace detail
+{
+
+template<class... T, class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<T...>, F && f )
+{
+    using A = int[sizeof...(T)];
+    return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
+}
+
+template<class F> BOOST_MP11_CONSTEXPR F mp_for_each_impl( mp_list<>, F && f )
+{
+    return std::forward<F>(f);
+}
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, >= 1900 )
+
+// msvc has a limit of 1024
+
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value <= 1024, F> mp_for_each( F && f )
+{
+    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
+}
+
+template<class L, class F> BOOST_MP11_CONSTEXPR mp_if_c<mp_size<L>::value >= 1025, F> mp_for_each( F && f )
+{
+    using L2 = mp_rename<L, mp_list>;
+
+    using L3 = mp_take_c<L2, 1024>;
+    using L4 = mp_drop_c<L2, 1024>;
+
+    return mp_for_each<L4>( mp_for_each<L3>( std::forward<F>(f) ) );
+}
+
+#else
+
+template<class L, class F> BOOST_MP11_CONSTEXPR F mp_for_each( F && f )
+{
+    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
+}
+
+#endif
+
+// mp_insert<L, I, T...>
+template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;
+
+// mp_insert_c<L, I, T...>
+template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;
+
+// mp_erase<L, I, J>
+template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;
+
+// mp_erase_c<L, I, J>
+template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;
+
+// mp_starts_with<L1, L2>
+// contributed by Glen Joseph Fernandes (glenjofe@gmail.com)
+namespace detail {
+
+template<class L1, class L2>
+struct mp_starts_with_impl { };
+
+template<template<class...> class L1, class... T1, template<class...> class L2,
+    class... T2>
+struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
+    template<class L>
+    static mp_false check(L);
+
+    template<class... T>
+    static mp_true check(mp_list<T2..., T...>);
+
+    using type = decltype(check(mp_list<T1...>()));
+};
+
+} // namespace detail
+
+template<class L1, class L2>
+using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;
+
+// mp_rotate_left(_c)<L, N>
+namespace detail
+{
+
+// limit divisor to 1 to avoid division by 0 and give a rotation of 0 for lists containing 0 or 1 elements
+template<std::size_t Ln, std::size_t N> using canonical_left_rotation = mp_size_t<N % (Ln == 0? 1: Ln)>;
+
+// perform right rotation as a left rotation by inverting the number of elements to rotate
+template<std::size_t Ln, std::size_t N> using canonical_right_rotation = mp_size_t<Ln - N % (Ln == 0? 1: Ln)>;
+
+// avoid errors when rotating fixed-sized lists by using mp_list for the transformation
+template<class L, class N, class L2 = mp_rename<L, mp_list>> using mp_rotate_impl = mp_assign<L, mp_append< mp_drop<L2, N>, mp_take<L2, N> >>;
+
+} // namespace detail
+
+template<class L, std::size_t N> using mp_rotate_left_c = detail::mp_rotate_impl<L, detail::canonical_left_rotation<mp_size<L>::value, N>>;
+template<class L, class N> using mp_rotate_left = mp_rotate_left_c<L, std::size_t{ N::value }>;
+
+// mp_rotate_right(_c)<L, N>
+template<class L, std::size_t N> using mp_rotate_right_c = mp_rotate_left<L, detail::canonical_right_rotation<mp_size<L>::value, N>>;
+template<class L, class N> using mp_rotate_right = mp_rotate_right_c<L, std::size_t{ N::value }>;
+
+// mp_min_element<L, P>
+// mp_max_element<L, P>
+//   in detail/mp_min_element.hpp
+
+// mp_power_set<L>
+namespace detail
+{
+
+template<class L> struct mp_power_set_impl;
+
+} // namespace detail
+
+template<class L> using mp_power_set = typename detail::mp_power_set_impl<L>::type;
+
+namespace detail
+{
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T> struct mp_power_set_impl< L<T...> >
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = L< L<> >;
+};
+
+#else
+
+template<template<class...> class L> struct mp_power_set_impl< L<> >
+{
+    using type = L< L<> >;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
+{
+    using S1 = mp_power_set< L<T...> >;
+
+    template<class L2> using _f = mp_push_front<L2, T1>;
+
+    using S2 = mp_transform<_f, S1>;
+
+    using type = mp_append< S1, S2 >;
+};
+
+} // namespace detail
+
+// mp_partial_sum<L, V, F>
+namespace detail
+{
+
+template<template<class...> class F> struct mp_partial_sum_impl_f
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1900 )
+
+    template<class V, class T> using fn = mp_list<F<mp_first<V>, T>, mp_push_back<mp_second<V>, F<mp_first<V>, T>> >;
+
+#else
+
+    template<class V, class T, class N = F<mp_first<V>, T>> using fn = mp_list<N, mp_push_back<mp_second<V>, N>>;
+
+#endif
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_partial_sum = mp_second<mp_fold_q<L, mp_list<V, mp_clear<L>>, detail::mp_partial_sum_impl_f<F>> >;
+template<class L, class V, class Q> using mp_partial_sum_q = mp_partial_sum<L, V, Q::template fn>;
+
+// mp_iterate<V, F, R>
+namespace detail
+{
+
+template<class V, template<class...> class F, template<class...> class R, class N> struct mp_iterate_impl;
+
+} // namespace detail
+
+template<class V, template<class...> class F, template<class...> class R> using mp_iterate = typename detail::mp_iterate_impl<V, F, R, mp_valid<R, V>>::type;
+
+namespace detail
+{
+
+template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_false>
+{
+    template<class X> using _f = mp_list<F<X>>;
+    using type = mp_eval_or<mp_list<>, _f, V>;
+};
+
+template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_true>
+{
+    using type = mp_push_front<mp_iterate<R<V>, F, R>, F<V>>;
+};
+
+} // namespace detail
+
+template<class V, class Qf, class Qr> using mp_iterate_q = mp_iterate<V, Qf::template fn, Qr::template fn>;
+
+// mp_pairwise_fold<L, F>
+namespace detail
+{
+
+template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_pop_back<L>, mp_pop_front<L>>;
+
+} // namespace detail
+
+template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
+template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;
+
+// mp_intersperse<L, S>
+namespace detail
+{
+
+template<class L, class S> struct mp_intersperse_impl
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class S> struct mp_intersperse_impl<L<T...>, S>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = L<>;
+};
+
+#else
+
+template<template<class...> class L, class S> struct mp_intersperse_impl<L<>, S>
+{
+    using type = L<>;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class S> struct mp_intersperse_impl<L<T1, T...>, S>
+{
+    using type = mp_append<L<T1>, L<S, T>...>;
+};
+
+} // namespace detail
+
+template<class L, class S> using mp_intersperse = typename detail::mp_intersperse_impl<L, S>::type;
+
+// mp_split<L, S>
+namespace detail
+{
+
+template<class L, class S, class J> struct mp_split_impl;
+
+} // namespace detail
+
+template<class L, class S> using mp_split = typename detail::mp_split_impl<L, S, mp_find<L, S>>::type;
+
+namespace detail
+{
+
+template<class L, class S, class J> using mp_split_impl_ = mp_push_front<mp_split<mp_drop_c<L, J::value + 1>, S>, mp_take<L, J>>;
+
+template<class L, class S, class J> struct mp_split_impl
+{
+    using type = mp_eval_if_c<mp_size<L>::value == J::value, mp_push_back<mp_clear<L>, L>, mp_split_impl_, L, S, J>;
+};
+
+} // namespace detail
+
+// mp_join<L, S>
+
+template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L, mp_list<S>>>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_ALGORITHM_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp
new file mode 100644
index 0000000000..764bd598da
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/config.hpp
@@ -0,0 +1,138 @@
+#ifndef BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
+
+// Copyright 2016, 2018, 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
+
+// BOOST_MP11_WORKAROUND
+
+#if defined( BOOST_STRICT_CONFIG ) || defined( BOOST_MP11_NO_WORKAROUNDS )
+
+# define BOOST_MP11_WORKAROUND( symbol, test ) 0
+
+#else
+
+# define BOOST_MP11_WORKAROUND( symbol, test ) ((symbol) != 0 && ((symbol) test))
+
+#endif
+
+//
+
+#define BOOST_MP11_CUDA 0
+#define BOOST_MP11_CLANG 0
+#define BOOST_MP11_INTEL 0
+#define BOOST_MP11_GCC 0
+#define BOOST_MP11_MSVC 0
+
+#define BOOST_MP11_CONSTEXPR constexpr
+
+#if defined( __CUDACC__ )
+
+// nvcc
+
+# undef BOOST_MP11_CUDA
+# define BOOST_MP11_CUDA (__CUDACC_VER_MAJOR__ * 1000000 + __CUDACC_VER_MINOR__ * 10000 + __CUDACC_VER_BUILD__)
+
+// CUDA (8.0) has no constexpr support in msvc mode:
+# if defined(_MSC_VER) && (BOOST_MP11_CUDA < 9000000)
+
+#  define BOOST_MP11_NO_CONSTEXPR
+
+#  undef BOOST_MP11_CONSTEXPR
+#  define BOOST_MP11_CONSTEXPR
+
+# endif
+
+#endif
+
+#if defined(__clang__)
+
+// Clang
+
+# undef BOOST_MP11_CLANG
+# define BOOST_MP11_CLANG (__clang_major__ * 100 + __clang_minor__)
+
+# if defined(__has_cpp_attribute)
+#  if __has_cpp_attribute(fallthrough) && __cplusplus >= 201406L // Clang 3.9+ in c++1z mode
+#   define BOOST_MP11_HAS_FOLD_EXPRESSIONS
+#  endif
+# endif
+
+#if BOOST_MP11_CLANG < 400 && __cplusplus >= 201402L \
+   && defined( __GLIBCXX__ ) && !__has_include(<shared_mutex>)
+
+// Clang pre-4 in C++14 mode, libstdc++ pre-4.9, ::gets is not defined,
+// but Clang tries to import it into std
+
+   extern "C" char *gets (char *__s);
+#endif
+
+#elif defined(__INTEL_COMPILER)
+
+// Intel C++
+
+# undef BOOST_MP11_INTEL
+# define BOOST_MP11_INTEL __INTEL_COMPILER
+
+#elif defined(__GNUC__)
+
+// g++
+
+# undef BOOST_MP11_GCC
+# define BOOST_MP11_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+
+#elif defined(_MSC_VER)
+
+// MS Visual C++
+
+# undef BOOST_MP11_MSVC
+# define BOOST_MP11_MSVC _MSC_VER
+
+# if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+#  define BOOST_MP11_NO_CONSTEXPR
+# endif
+
+#if _MSC_FULL_VER < 190024210 // 2015u3
+#  undef BOOST_MP11_CONSTEXPR
+#  define BOOST_MP11_CONSTEXPR
+#endif
+
+#endif
+
+// BOOST_MP11_HAS_CXX14_CONSTEXPR
+
+#if !defined(BOOST_MP11_NO_CONSTEXPR) && defined(__cpp_constexpr) && __cpp_constexpr >= 201304
+#  define BOOST_MP11_HAS_CXX14_CONSTEXPR
+#endif
+
+// BOOST_MP11_HAS_FOLD_EXPRESSIONS
+
+#if !defined(BOOST_MP11_HAS_FOLD_EXPRESSIONS) && defined(__cpp_fold_expressions) && __cpp_fold_expressions >= 201603
+#  define BOOST_MP11_HAS_FOLD_EXPRESSIONS
+#endif
+
+// BOOST_MP11_HAS_TYPE_PACK_ELEMENT
+
+#if defined(__has_builtin)
+# if __has_builtin(__type_pack_element)
+#  define BOOST_MP11_HAS_TYPE_PACK_ELEMENT
+# endif
+#endif
+
+// BOOST_MP11_DEPRECATED(msg)
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CLANG, < 304 )
+#  define BOOST_MP11_DEPRECATED(msg)
+#elif defined(__GNUC__) || defined(__clang__)
+#  define BOOST_MP11_DEPRECATED(msg) __attribute__((deprecated(msg)))
+#elif defined(_MSC_VER) && _MSC_VER >= 1900
+#  define BOOST_MP11_DEPRECATED(msg) [[deprecated(msg)]]
+#else
+#  define BOOST_MP11_DEPRECATED(msg)
+#endif
+
+#endif // #ifndef BOOST_MP11_DETAIL_CONFIG_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp
new file mode 100644
index 0000000000..937d15ebe4
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_append.hpp
@@ -0,0 +1,185 @@
+#ifndef BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
+
+//  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/detail/mp_list.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_append<L...>
+
+namespace detail
+{
+
+template<class... L> struct mp_append_impl;
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<class... L> struct mp_append_impl
+{
+};
+
+template<> struct mp_append_impl<>
+{
+    using type = mp_list<>;
+};
+
+template<template<class...> class L, class... T> struct mp_append_impl<L<T...>>
+{
+    using type = L<T...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_append_impl<L1<T1...>, L2<T2...>>
+{
+    using type = L1<T1..., T2...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>>
+{
+    using type = L1<T1..., T2..., T3...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>>
+{
+    using type = L1<T1..., T2..., T3..., T4...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, template<class...> class L5, class... T5, class... Lr> struct mp_append_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, Lr...>
+{
+    using type = typename mp_append_impl<L1<T1..., T2..., T3..., T4..., T5...>, Lr...>::type;
+};
+
+#else
+
+template<class L1 = mp_list<>, class L2 = mp_list<>, class L3 = mp_list<>, class L4 = mp_list<>, class L5 = mp_list<>, class L6 = mp_list<>, class L7 = mp_list<>, class L8 = mp_list<>, class L9 = mp_list<>, class L10 = mp_list<>, class L11 = mp_list<>> struct append_11_impl
+{
+};
+
+template<
+    template<class...> class L1, class... T1,
+    template<class...> class L2, class... T2,
+    template<class...> class L3, class... T3,
+    template<class...> class L4, class... T4,
+    template<class...> class L5, class... T5,
+    template<class...> class L6, class... T6,
+    template<class...> class L7, class... T7,
+    template<class...> class L8, class... T8,
+    template<class...> class L9, class... T9,
+    template<class...> class L10, class... T10,
+    template<class...> class L11, class... T11>
+
+struct append_11_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, L6<T6...>, L7<T7...>, L8<T8...>, L9<T9...>, L10<T10...>, L11<T11...>>
+{
+    using type = L1<T1..., T2..., T3..., T4..., T5..., T6..., T7..., T8..., T9..., T10..., T11...>;
+};
+
+template<
+
+    class L00 = mp_list<>, class L01 = mp_list<>, class L02 = mp_list<>, class L03 = mp_list<>, class L04 = mp_list<>, class L05 = mp_list<>, class L06 = mp_list<>, class L07 = mp_list<>, class L08 = mp_list<>, class L09 = mp_list<>, class L0A = mp_list<>,
+    class L10 = mp_list<>, class L11 = mp_list<>, class L12 = mp_list<>, class L13 = mp_list<>, class L14 = mp_list<>, class L15 = mp_list<>, class L16 = mp_list<>, class L17 = mp_list<>, class L18 = mp_list<>, class L19 = mp_list<>,
+    class L20 = mp_list<>, class L21 = mp_list<>, class L22 = mp_list<>, class L23 = mp_list<>, class L24 = mp_list<>, class L25 = mp_list<>, class L26 = mp_list<>, class L27 = mp_list<>, class L28 = mp_list<>, class L29 = mp_list<>,
+    class L30 = mp_list<>, class L31 = mp_list<>, class L32 = mp_list<>, class L33 = mp_list<>, class L34 = mp_list<>, class L35 = mp_list<>, class L36 = mp_list<>, class L37 = mp_list<>, class L38 = mp_list<>, class L39 = mp_list<>,
+    class L40 = mp_list<>, class L41 = mp_list<>, class L42 = mp_list<>, class L43 = mp_list<>, class L44 = mp_list<>, class L45 = mp_list<>, class L46 = mp_list<>, class L47 = mp_list<>, class L48 = mp_list<>, class L49 = mp_list<>,
+    class L50 = mp_list<>, class L51 = mp_list<>, class L52 = mp_list<>, class L53 = mp_list<>, class L54 = mp_list<>, class L55 = mp_list<>, class L56 = mp_list<>, class L57 = mp_list<>, class L58 = mp_list<>, class L59 = mp_list<>,
+    class L60 = mp_list<>, class L61 = mp_list<>, class L62 = mp_list<>, class L63 = mp_list<>, class L64 = mp_list<>, class L65 = mp_list<>, class L66 = mp_list<>, class L67 = mp_list<>, class L68 = mp_list<>, class L69 = mp_list<>,
+    class L70 = mp_list<>, class L71 = mp_list<>, class L72 = mp_list<>, class L73 = mp_list<>, class L74 = mp_list<>, class L75 = mp_list<>, class L76 = mp_list<>, class L77 = mp_list<>, class L78 = mp_list<>, class L79 = mp_list<>,
+    class L80 = mp_list<>, class L81 = mp_list<>, class L82 = mp_list<>, class L83 = mp_list<>, class L84 = mp_list<>, class L85 = mp_list<>, class L86 = mp_list<>, class L87 = mp_list<>, class L88 = mp_list<>, class L89 = mp_list<>,
+    class L90 = mp_list<>, class L91 = mp_list<>, class L92 = mp_list<>, class L93 = mp_list<>, class L94 = mp_list<>, class L95 = mp_list<>, class L96 = mp_list<>, class L97 = mp_list<>, class L98 = mp_list<>, class L99 = mp_list<>,
+    class LA0 = mp_list<>, class LA1 = mp_list<>, class LA2 = mp_list<>, class LA3 = mp_list<>, class LA4 = mp_list<>, class LA5 = mp_list<>, class LA6 = mp_list<>, class LA7 = mp_list<>, class LA8 = mp_list<>, class LA9 = mp_list<>
+
+> struct append_111_impl
+{
+    using type = typename append_11_impl<
+
+        typename append_11_impl<L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A>::type,
+        typename append_11_impl<mp_list<>, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type,
+        typename append_11_impl<mp_list<>, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type,
+        typename append_11_impl<mp_list<>, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type,
+        typename append_11_impl<mp_list<>, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type,
+        typename append_11_impl<mp_list<>, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type,
+        typename append_11_impl<mp_list<>, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type,
+        typename append_11_impl<mp_list<>, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type,
+        typename append_11_impl<mp_list<>, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type,
+        typename append_11_impl<mp_list<>, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type,
+        typename append_11_impl<mp_list<>, LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9>::type
+
+    >::type;
+};
+
+template<
+
+    class L00, class L01, class L02, class L03, class L04, class L05, class L06, class L07, class L08, class L09, class L0A,
+    class L10, class L11, class L12, class L13, class L14, class L15, class L16, class L17, class L18, class L19,
+    class L20, class L21, class L22, class L23, class L24, class L25, class L26, class L27, class L28, class L29,
+    class L30, class L31, class L32, class L33, class L34, class L35, class L36, class L37, class L38, class L39,
+    class L40, class L41, class L42, class L43, class L44, class L45, class L46, class L47, class L48, class L49,
+    class L50, class L51, class L52, class L53, class L54, class L55, class L56, class L57, class L58, class L59,
+    class L60, class L61, class L62, class L63, class L64, class L65, class L66, class L67, class L68, class L69,
+    class L70, class L71, class L72, class L73, class L74, class L75, class L76, class L77, class L78, class L79,
+    class L80, class L81, class L82, class L83, class L84, class L85, class L86, class L87, class L88, class L89,
+    class L90, class L91, class L92, class L93, class L94, class L95, class L96, class L97, class L98, class L99,
+    class LA0, class LA1, class LA2, class LA3, class LA4, class LA5, class LA6, class LA7, class LA8, class LA9,
+    class... Lr
+
+> struct append_inf_impl
+{
+    using prefix = typename append_111_impl<
+
+        L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A,
+        L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
+        L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
+        L30, L31, L32, L33, L34, L35, L36, L37, L38, L39,
+        L40, L41, L42, L43, L44, L45, L46, L47, L48, L49,
+        L50, L51, L52, L53, L54, L55, L56, L57, L58, L59,
+        L60, L61, L62, L63, L64, L65, L66, L67, L68, L69,
+        L70, L71, L72, L73, L74, L75, L76, L77, L78, L79,
+        L80, L81, L82, L83, L84, L85, L86, L87, L88, L89,
+        L90, L91, L92, L93, L94, L95, L96, L97, L98, L99,
+        LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9
+
+    >::type;
+
+    using type = typename mp_append_impl<prefix, Lr...>::type;
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<class... L>
+struct mp_append_impl_cuda_workaround
+{
+    using type = mp_if_c<(sizeof...(L) > 111), mp_quote<append_inf_impl>, mp_if_c<(sizeof...(L) > 11), mp_quote<append_111_impl>, mp_quote<append_11_impl> > >;
+};
+
+template<class... L> struct mp_append_impl: mp_append_impl_cuda_workaround<L...>::type::template fn<L...>
+{
+};
+
+#else
+
+template<class... L> struct mp_append_impl: mp_if_c<(sizeof...(L) > 111), mp_quote<append_inf_impl>, mp_if_c<(sizeof...(L) > 11), mp_quote<append_111_impl>, mp_quote<append_11_impl> > >::template fn<L...>
+{
+};
+
+#endif
+
+#endif
+
+} // namespace detail
+
+template<class... L> using mp_append = typename detail::mp_append_impl<L...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_APPEND_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_copy_if.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_copy_if.hpp
new file mode 100644
index 0000000000..4edcde090f
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_copy_if.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
+
+//  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/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_copy_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_copy_if_impl
+{
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_copy_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+    template<class U> struct _f { using type = mp_if<P<U>, mp_list<U>, mp_list<>>; };
+    using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+    template<class U> using _f = mp_if<P<U>, mp_list<U>, mp_list<>>;
+    using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_copy_if = typename detail::mp_copy_if_impl<L, P>::type;
+template<class L, class Q> using mp_copy_if_q = mp_copy_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_COPY_IF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_count.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_count.hpp
new file mode 100644
index 0000000000..37b39ed547
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_count.hpp
@@ -0,0 +1,147 @@
+#ifndef BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
+
+//  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/integral.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_count<L, V>
+namespace detail
+{
+
+#if !defined( BOOST_MP11_NO_CONSTEXPR )
+
+constexpr std::size_t cx_plus()
+{
+    return 0;
+}
+
+template<class T1, class... T> constexpr std::size_t cx_plus(T1 t1, T... t)
+{
+    return static_cast<std::size_t>(t1) + cx_plus(t...);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T>
+constexpr std::size_t cx_plus(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T... t)
+{
+    return static_cast<std::size_t>(t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9 + t10) + cx_plus(t...);
+}
+
+#endif
+
+template<class L, class V> struct mp_count_impl;
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+
+template<class V, class... T> constexpr std::size_t cx_count()
+{
+    constexpr bool a[] = { false, std::is_same<T, V>::value... };
+
+    std::size_t r = 0;
+
+    for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
+    {
+        r += a[ i ];
+    }
+
+    return r;
+}
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+    using type = mp_size_t<cx_count<V, T...>()>;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+    using type = mp_size_t<cx_plus(std::is_same<T, V>::value...)>;
+};
+
+#else
+
+template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
+{
+    using type = mp_size_t<mp_plus<std::is_same<T, V>...>::value>;
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, class V> using mp_count = typename detail::mp_count_impl<L, V>::type;
+
+// mp_count_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_count_if_impl;
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<template<class...> class P, class... T> constexpr std::size_t cx_count_if()
+{
+    constexpr bool a[] = { false, static_cast<bool>( P<T>::value )... };
+
+    std::size_t r = 0;
+
+    for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
+    {
+        r += a[ i ];
+    }
+
+    return r;
+}
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+    using type = mp_size_t<cx_count_if<P, T...>()>;
+};
+
+#elif !defined( BOOST_MP11_NO_CONSTEXPR )
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+    using type = mp_size_t<cx_plus(mp_to_bool<P<T>>::value...)>;
+};
+
+#else
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+    template<class T> struct _f { using type = mp_to_bool<P<T>>; };
+    using type = mp_size_t<mp_plus<typename _f<T>::type...>::value>;
+
+#else
+
+    using type = mp_size_t<mp_plus<mp_to_bool<P<T>>...>::value>;
+
+#endif
+};
+
+#endif
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_count_if = typename detail::mp_count_if_impl<L, P>::type;
+template<class L, class Q> using mp_count_if_q = mp_count_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_COUNT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp
new file mode 100644
index 0000000000..0745e876f6
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_fold.hpp
@@ -0,0 +1,62 @@
+#ifndef BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
+
+//  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/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_fold<L, V, F>
+namespace detail
+{
+
+template<class L, class V, template<class...> class F> struct mp_fold_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_fold is not a list
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, <= 1800 )
+
+template<template<class...> class L, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T...>, V, F>
+{
+    static_assert( sizeof...(T) == 0, "T... must be empty" );
+    using type = V;
+};
+
+#else
+
+template<template<class...> class L, class V, template<class...> class F> struct mp_fold_impl<L<>, V, F>
+{
+    using type = V;
+};
+
+#endif
+
+template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T...>, V, F>
+{
+    using type = typename mp_fold_impl<L<T...>, F<V, T1>, F>::type;
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
+{
+    using type = typename mp_fold_impl<L<T...>, F<F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>, T10>, F>::type;
+};
+
+} // namespace detail
+
+template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
+template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_FOLD_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp
new file mode 100644
index 0000000000..de83d0929b
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_front.hpp
@@ -0,0 +1,38 @@
+#ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
+
+//  Copyright 2015-2021 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_front<L>
+namespace detail
+{
+
+template<class L> struct mp_front_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class T1, class... T> struct mp_front_impl<L<T1, T...>>
+{
+    using type = T1;
+};
+
+} // namespace detail
+
+template<class L> using mp_front = typename detail::mp_front_impl<L>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_FRONT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_list.hpp
new file mode 100644
index 0000000000..25b378bde4
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_is_list.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
+
+// 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/mp11/integral.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_is_list<L>
+namespace detail
+{
+
+template<class L> struct mp_is_list_impl
+{
+    using type = mp_false;
+};
+
+template<template<class...> class L, class... T> struct mp_is_list_impl<L<T...>>
+{
+    using type = mp_true;
+};
+
+} // namespace detail
+
+template<class L> using mp_is_list = typename detail::mp_is_list_impl<L>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_IS_LIST_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list.hpp
new file mode 100644
index 0000000000..8e8d3e5e98
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_list.hpp
@@ -0,0 +1,24 @@
+#ifndef BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
+
+//  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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_list<T...>
+template<class... T> struct mp_list
+{
+};
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_LIST_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp
new file mode 100644
index 0000000000..5ba58a44f2
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_map_find.hpp
@@ -0,0 +1,87 @@
+#ifndef BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
+
+//  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>
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+// not exactly good practice, but...
+namespace std
+{
+    template<class... _Types> class tuple;
+}
+
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_map_find
+namespace detail
+{
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<class T> using mpmf_wrap = mp_identity<T>;
+template<class T> using mpmf_unwrap = typename T::type;
+
+#else
+
+template<class... T> struct mpmf_tuple {};
+
+template<class T> struct mpmf_wrap_impl
+{
+    using type = mp_identity<T>;
+};
+
+template<class... T> struct mpmf_wrap_impl< std::tuple<T...> >
+{
+    using type = mp_identity< mpmf_tuple<T...> >;
+};
+
+template<class T> using mpmf_wrap = typename mpmf_wrap_impl<T>::type;
+
+template<class T> struct mpmf_unwrap_impl
+{
+    using type = typename T::type;
+};
+
+template<class... T> struct mpmf_unwrap_impl< mp_identity< mpmf_tuple<T...> > >
+{
+    using type = std::tuple<T...>;
+};
+
+template<class T> using mpmf_unwrap = typename mpmf_unwrap_impl<T>::type;
+
+#endif // #if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1930 )
+
+template<class M, class K> struct mp_map_find_impl;
+
+template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
+{
+    using U = mp_inherit<mpmf_wrap<T>...>;
+
+    template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
+    static mp_identity<void> f( ... );
+
+    using type = mpmf_unwrap< decltype( f((U*)0) ) >;
+};
+
+} // namespace detail
+
+template<class M, class K> using mp_map_find = typename detail::mp_map_find_impl<M, K>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_MAP_FIND_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_min_element.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_min_element.hpp
new file mode 100644
index 0000000000..55c21acd05
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_min_element.hpp
@@ -0,0 +1,51 @@
+#ifndef BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
+
+//  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/detail/mp_fold.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/utility.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_min_element<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct select_min
+{
+    template<class T1, class T2> using fn = mp_if<P<T1, T2>, T1, T2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_min_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_min<P>>;
+template<class L, class Q> using mp_min_element_q = mp_min_element<L, Q::template fn>;
+
+// mp_max_element<L, P>
+namespace detail
+{
+
+template<template<class...> class P> struct select_max
+{
+    template<class T1, class T2> using fn = mp_if<P<T2, T1>, T1, T2>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_max_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_max<P>>;
+template<class L, class Q> using mp_max_element_q = mp_max_element<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_MIN_ELEMENT_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp
new file mode 100644
index 0000000000..90ed4c9d11
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_plus.hpp
@@ -0,0 +1,81 @@
+#ifndef BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
+
+//  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/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_plus
+namespace detail
+{
+
+#if defined( BOOST_MP11_HAS_FOLD_EXPRESSIONS ) && !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+
+template<class... T> struct mp_plus_impl
+{
+    static const auto _v = (T::value + ... + 0);
+    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#else
+
+template<class... T> struct mp_plus_impl;
+
+template<> struct mp_plus_impl<>
+{
+    using type = std::integral_constant<int, 0>;
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 40800 )
+
+template<class T1, class... T> struct mp_plus_impl<T1, T...>
+{
+    static const decltype(T1::value + mp_plus_impl<T...>::type::value) _v = T1::value + mp_plus_impl<T...>::type::value;
+    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_plus_impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>
+{
+    static const
+        decltype(T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value)
+        _v = T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value;
+    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#else
+
+template<class T1, class... T> struct mp_plus_impl<T1, T...>
+{
+    static const auto _v = T1::value + mp_plus_impl<T...>::type::value;
+    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_plus_impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>
+{
+    static const auto _v = T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value;
+    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
+};
+
+#endif
+
+#endif
+
+} // namespace detail
+
+template<class... T> using mp_plus = typename detail::mp_plus_impl<T...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_PLUS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_remove_if.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_remove_if.hpp
new file mode 100644
index 0000000000..9687b4a16d
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_remove_if.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
+
+//  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/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_remove_if<L, P>
+namespace detail
+{
+
+template<class L, template<class...> class P> struct mp_remove_if_impl
+{
+};
+
+template<template<class...> class L, class... T, template<class...> class P> struct mp_remove_if_impl<L<T...>, P>
+{
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 )
+    template<class U> struct _f { using type = mp_if<P<U>, mp_list<>, mp_list<U>>; };
+    using type = mp_append<L<>, typename _f<T>::type...>;
+#else
+    template<class U> using _f = mp_if<P<U>, mp_list<>, mp_list<U>>;
+    using type = mp_append<L<>, _f<T>...>;
+#endif
+};
+
+} // namespace detail
+
+template<class L, template<class...> class P> using mp_remove_if = typename detail::mp_remove_if_impl<L, P>::type;
+template<class L, class Q> using mp_remove_if_q = mp_remove_if<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_REMOVE_IF_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp
new file mode 100644
index 0000000000..8368ac68ad
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_rename.hpp
@@ -0,0 +1,41 @@
+#ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
+
+//  Copyright 2015-2021 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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_rename<L, B>
+namespace detail
+{
+
+template<class A, template<class...> class B> struct mp_rename_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_rename is not a list
+};
+
+template<template<class...> class A, class... T, template<class...> class B> struct mp_rename_impl<A<T...>, B>
+{
+    using type = B<T...>;
+};
+
+} // namespace detail
+
+template<class A, template<class...> class B> using mp_rename = typename detail::mp_rename_impl<A, B>::type;
+
+template<template<class...> class F, class L> using mp_apply = typename detail::mp_rename_impl<L, F>::type;
+
+template<class Q, class L> using mp_apply_q = typename detail::mp_rename_impl<L, Q::template fn>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_RENAME_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_void.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_void.hpp
new file mode 100644
index 0000000000..a7ac7b7162
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_void.hpp
@@ -0,0 +1,32 @@
+#ifndef BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
+
+//  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
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_void<T...>
+namespace detail
+{
+
+template<class... T> struct mp_void_impl
+{
+    using type = void;
+};
+
+} // namespace detail
+
+template<class... T> using mp_void = typename detail::mp_void_impl<T...>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_VOID_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_with_index.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_with_index.hpp
new file mode 100644
index 0000000000..b6932f2d4f
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mp_with_index.hpp
@@ -0,0 +1,385 @@
+#ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
+
+//  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/integral.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+
+#if defined( BOOST_MP11_HAS_CXX14_CONSTEXPR )
+# define BOOST_MP11_CONSTEXPR14 constexpr
+#else
+# define BOOST_MP11_CONSTEXPR14
+#endif
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# define BOOST_MP11_UNREACHABLE_DEFAULT default: __builtin_unreachable();
+#elif defined( _MSC_VER )
+# define BOOST_MP11_UNREACHABLE_DEFAULT default: __assume(false);
+#else
+# define BOOST_MP11_UNREACHABLE_DEFAULT
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+namespace detail
+{
+
+template<std::size_t N> struct mp_with_index_impl_
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        if( i < N / 2 )
+        {
+            return mp_with_index_impl_<N/2>::template call<K>( i, std::forward<F>(f) );
+        }
+        else
+        {
+            return mp_with_index_impl_<N-N/2>::template call<K+N/2>( i - N/2, std::forward<F>(f) );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<0>
+{
+};
+
+template<> struct mp_with_index_impl_<1>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t /*i*/, F && f )
+    {
+        return std::forward<F>(f)( mp_size_t<K+0>() );
+    }
+};
+
+template<> struct mp_with_index_impl_<2>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<3>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<4>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<5>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<6>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<7>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<8>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<9>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<10>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<11>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<12>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<13>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<14>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<15>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
+        }
+    }
+};
+
+template<> struct mp_with_index_impl_<16>
+{
+    template<std::size_t K, class F> static BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
+    {
+        switch( i )
+        {
+        BOOST_MP11_UNREACHABLE_DEFAULT
+        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
+        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
+        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
+        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
+        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
+        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
+        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
+        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
+        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
+        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
+        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
+        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
+        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
+        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
+        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
+        case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
+        }
+    }
+};
+
+} // namespace detail
+
+template<std::size_t N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
+{
+    assert( i < N );
+    return detail::mp_with_index_impl_<N>::template call<0>( i, std::forward<F>(f) );
+}
+
+template<class N, class F> inline BOOST_MP11_CONSTEXPR14 decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
+{
+    return mp_with_index<std::size_t{N::value}>( i, std::forward<F>(f) );
+}
+
+#undef BOOST_MP11_CONSTEXPR14
+#undef BOOST_MP11_UNREACHABLE_DEFAULT
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MP_WITH_INDEX_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/detail/mpl_common.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mpl_common.hpp
new file mode 100644
index 0000000000..208885cbd0
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/detail/mpl_common.hpp
@@ -0,0 +1,160 @@
+#ifndef BOOST_MP11_DETAIL_MPL_COMMON_HPP_INCLUDED
+#define BOOST_MP11_DETAIL_MPL_COMMON_HPP_INCLUDED
+
+// 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/list.hpp>
+#include <boost/mp11/algorithm.hpp>
+
+namespace boost
+{
+namespace mpl
+{
+
+struct forward_iterator_tag;
+
+namespace aux
+{
+
+struct mp11_tag {};
+
+template<class L> struct mp11_iterator
+{
+    using category = forward_iterator_tag;
+
+    using type = mp11::mp_first<L>;
+    using next = mp11_iterator<mp11::mp_rest<L>>;
+};
+
+} // namespace aux
+
+// at
+
+template< typename Tag > struct at_impl;
+
+template<> struct at_impl<aux::mp11_tag>
+{
+    template<class L, class I> struct apply
+    {
+        using type = mp11::mp_at<L, I>;
+    };
+};
+
+// back
+
+template< typename Tag > struct back_impl;
+
+template<> struct back_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using N = mp11::mp_size<L>;
+        using type = mp11::mp_at_c<L, N::value - 1>;
+    };
+};
+
+// begin
+
+template< typename Tag > struct begin_impl;
+
+template<> struct begin_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = aux::mp11_iterator<L>;
+    };
+};
+
+// clear
+
+template< typename Tag > struct clear_impl;
+
+template<> struct clear_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = mp11::mp_clear<L>;
+    };
+};
+
+// end
+
+template< typename Tag > struct end_impl;
+
+template<> struct end_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = aux::mp11_iterator<mp11::mp_clear<L>>;
+    };
+};
+
+// front
+
+template< typename Tag > struct front_impl;
+
+template<> struct front_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = mp11::mp_front<L>;
+    };
+};
+
+// pop_front
+
+template< typename Tag > struct pop_front_impl;
+
+template<> struct pop_front_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = mp11::mp_pop_front<L>;
+    };
+};
+
+// push_back
+
+template< typename Tag > struct push_back_impl;
+
+template<> struct push_back_impl<aux::mp11_tag>
+{
+    template<class L, class T> struct apply
+    {
+        using type = mp11::mp_push_back<L, T>;
+    };
+};
+
+// push_front
+
+template< typename Tag > struct push_front_impl;
+
+template<> struct push_front_impl<aux::mp11_tag>
+{
+    template<class L, class T> struct apply
+    {
+        using type = mp11::mp_push_front<L, T>;
+    };
+};
+
+// size
+
+template< typename Tag > struct size_impl;
+
+template<> struct size_impl<aux::mp11_tag>
+{
+    template<class L> struct apply
+    {
+        using type = mp11::mp_size<L>;
+    };
+};
+
+} // namespace mpl
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_DETAIL_MPL_COMMON_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/function.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/function.hpp
new file mode 100644
index 0000000000..e20b45200a
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/function.hpp
@@ -0,0 +1,222 @@
+#ifndef BOOST_MP11_FUNCTION_HPP_INCLUDED
+#define BOOST_MP11_FUNCTION_HPP_INCLUDED
+
+// 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/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_count.hpp>
+#include <boost/mp11/detail/mp_plus.hpp>
+#include <boost/mp11/detail/mp_min_element.hpp>
+#include <boost/mp11/detail/mp_void.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_void<T...>
+//   in detail/mp_void.hpp
+
+// mp_and<T...>
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1910 )
+
+namespace detail
+{
+
+template<class... T> struct mp_and_impl;
+
+} // namespace detail
+
+template<class... T> using mp_and = mp_to_bool< typename detail::mp_and_impl<T...>::type >;
+
+namespace detail
+{
+
+template<> struct mp_and_impl<>
+{
+    using type = mp_true;
+};
+
+template<class T> struct mp_and_impl<T>
+{
+    using type = T;
+};
+
+template<class T1, class... T> struct mp_and_impl<T1, T...>
+{
+    using type = mp_eval_if< mp_not<T1>, T1, mp_and, T... >;
+};
+
+} // namespace detail
+
+#else
+
+namespace detail
+{
+
+template<class L, class E = void> struct mp_and_impl
+{
+    using type = mp_false;
+};
+
+template<class... T> struct mp_and_impl< mp_list<T...>, mp_void<mp_if<T, void>...> >
+{
+    using type = mp_true;
+};
+
+} // namespace detail
+
+template<class... T> using mp_and = typename detail::mp_and_impl<mp_list<T...>>::type;
+
+#endif
+
+// mp_all<T...>
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86355
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, != 0 )
+
+template<class... T> using mp_all = mp_bool< mp_count_if< mp_list<T...>, mp_not >::value == 0 >;
+
+#else
+
+template<class... T> using mp_all = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_false >::value == 0 >;
+
+#endif
+
+// mp_or<T...>
+namespace detail
+{
+
+template<class... T> struct mp_or_impl;
+
+} // namespace detail
+
+template<class... T> using mp_or = mp_to_bool< typename detail::mp_or_impl<T...>::type >;
+
+namespace detail
+{
+
+template<> struct mp_or_impl<>
+{
+    using type = mp_false;
+};
+
+template<class T> struct mp_or_impl<T>
+{
+    using type = T;
+};
+
+template<class T1, class... T> struct mp_or_impl<T1, T...>
+{
+    using type = mp_eval_if< T1, T1, mp_or, T... >;
+};
+
+} // namespace detail
+
+// mp_any<T...>
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86356
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1920 ) || BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, != 0 )
+
+template<class... T> using mp_any = mp_bool< mp_count_if< mp_list<T...>, mp_to_bool >::value != 0 >;
+
+#else
+
+template<class... T> using mp_any = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_true >::value != 0 >;
+
+#endif
+
+// mp_same<T...>
+namespace detail
+{
+
+template<class... T> struct mp_same_impl;
+
+template<> struct mp_same_impl<>
+{
+    using type = mp_true;
+};
+
+template<class T1, class... T> struct mp_same_impl<T1, T...>
+{
+    using type = mp_bool< mp_count<mp_list<T...>, T1>::value == sizeof...(T) >;
+};
+
+} // namespace detail
+
+template<class... T> using mp_same = typename detail::mp_same_impl<T...>::type;
+
+// mp_similar<T...>
+namespace detail
+{
+
+template<class... T> struct mp_similar_impl;
+
+template<> struct mp_similar_impl<>
+{
+    using type = mp_true;
+};
+
+template<class T> struct mp_similar_impl<T>
+{
+    using type = mp_true;
+};
+
+template<class T> struct mp_similar_impl<T, T>
+{
+    using type = mp_true;
+};
+
+template<class T1, class T2> struct mp_similar_impl<T1, T2>
+{
+    using type = mp_false;
+};
+
+template<template<class...> class L, class... T1, class... T2> struct mp_similar_impl<L<T1...>, L<T2...>>
+{
+    using type = mp_true;
+};
+
+template<template<class...> class L, class... T> struct mp_similar_impl<L<T...>, L<T...>>
+{
+    using type = mp_true;
+};
+
+template<class T1, class T2, class T3, class... T> struct mp_similar_impl<T1, T2, T3, T...>
+{
+    using type = mp_all< typename mp_similar_impl<T1, T2>::type, typename mp_similar_impl<T1, T3>::type, typename mp_similar_impl<T1, T>::type... >;
+};
+
+} // namespace detail
+
+template<class... T> using mp_similar = typename detail::mp_similar_impl<T...>::type;
+
+#if BOOST_MP11_GCC
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+// mp_less<T1, T2>
+template<class T1, class T2> using mp_less = mp_bool<(T1::value < 0 && T2::value >= 0) || ((T1::value < T2::value) && !(T1::value >= 0 && T2::value < 0))>;
+
+#if BOOST_MP11_GCC
+# pragma GCC diagnostic pop
+#endif
+
+// mp_min<T...>
+template<class T1, class... T> using mp_min = mp_min_element<mp_list<T1, T...>, mp_less>;
+
+// mp_max<T...>
+template<class T1, class... T> using mp_max = mp_max_element<mp_list<T1, T...>, mp_less>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_FUNCTION_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/integer_sequence.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/integer_sequence.hpp
new file mode 100644
index 0000000000..83e24501ba
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/integer_sequence.hpp
@@ -0,0 +1,112 @@
+#ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
+#define BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
+
+// 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/version.hpp>
+#include <cstddef>
+
+#if defined(__has_builtin)
+# if __has_builtin(__make_integer_seq)
+#  define BOOST_MP11_HAS_MAKE_INTEGER_SEQ
+# endif
+#endif
+
+namespace boost
+{
+namespace mp11
+{
+
+// integer_sequence
+template<class T, T... I> struct integer_sequence
+{
+};
+
+#if defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ)
+
+template<class T, T N> using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
+
+#else
+
+// detail::make_integer_sequence_impl
+namespace detail
+{
+
+// iseq_if_c
+template<bool C, class T, class E> struct iseq_if_c_impl;
+
+template<class T, class E> struct iseq_if_c_impl<true, T, E>
+{
+    using type = T;
+};
+
+template<class T, class E> struct iseq_if_c_impl<false, T, E>
+{
+    using type = E;
+};
+
+template<bool C, class T, class E> using iseq_if_c = typename iseq_if_c_impl<C, T, E>::type;
+
+// iseq_identity
+template<class T> struct iseq_identity
+{
+    using type = T;
+};
+
+template<class S1, class S2> struct append_integer_sequence;
+
+template<class T, T... I, T... J> struct append_integer_sequence<integer_sequence<T, I...>, integer_sequence<T, J...>>
+{
+    using type = integer_sequence< T, I..., ( J + sizeof...(I) )... >;
+};
+
+template<class T, T N> struct make_integer_sequence_impl;
+
+template<class T, T N> struct make_integer_sequence_impl_
+{
+private:
+
+    static_assert( N >= 0, "make_integer_sequence<T, N>: N must not be negative" );
+
+    static T const M = N / 2;
+    static T const R = N % 2;
+
+    using S1 = typename make_integer_sequence_impl<T, M>::type;
+    using S2 = typename append_integer_sequence<S1, S1>::type;
+    using S3 = typename make_integer_sequence_impl<T, R>::type;
+    using S4 = typename append_integer_sequence<S2, S3>::type;
+
+public:
+
+    using type = S4;
+};
+
+template<class T, T N> struct make_integer_sequence_impl: iseq_if_c<N == 0, iseq_identity<integer_sequence<T>>, iseq_if_c<N == 1, iseq_identity<integer_sequence<T, 0>>, make_integer_sequence_impl_<T, N> > >
+{
+};
+
+} // namespace detail
+
+// make_integer_sequence
+template<class T, T N> using make_integer_sequence = typename detail::make_integer_sequence_impl<T, N>::type;
+
+#endif // defined(BOOST_MP11_HAS_MAKE_INTEGER_SEQ)
+
+// index_sequence
+template<std::size_t... I> using index_sequence = integer_sequence<std::size_t, I...>;
+
+// make_index_sequence
+template<std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;
+
+// index_sequence_for
+template<class... T> using index_sequence_for = make_integer_sequence<std::size_t, sizeof...(T)>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_INTEGER_SEQUENCE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp
new file mode 100644
index 0000000000..067167343c
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/integral.hpp
@@ -0,0 +1,41 @@
+#ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED
+#define BOOST_MP11_INTEGRAL_HPP_INCLUDED
+
+//  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/version.hpp>
+#include <type_traits>
+#include <cstddef>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_bool
+template<bool B> using mp_bool = std::integral_constant<bool, B>;
+
+using mp_true = mp_bool<true>;
+using mp_false = mp_bool<false>;
+
+// mp_to_bool
+template<class T> using mp_to_bool = mp_bool<static_cast<bool>( T::value )>;
+
+// mp_not<T>
+template<class T> using mp_not = mp_bool< !T::value >;
+
+// mp_int
+template<int I> using mp_int = std::integral_constant<int, I>;
+
+// mp_size_t
+template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_INTEGRAL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp
new file mode 100644
index 0000000000..6572a62697
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/list.hpp
@@ -0,0 +1,304 @@
+#ifndef BOOST_MP11_LIST_HPP_INCLUDED
+#define BOOST_MP11_LIST_HPP_INCLUDED
+
+//  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/integral.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_is_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_front.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/config.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_list_c<T, I...>
+template<class T, T... I> using mp_list_c = mp_list<std::integral_constant<T, I>...>;
+
+// mp_is_list<L>
+//   in detail/mp_is_list.hpp
+
+// mp_size<L>
+namespace detail
+{
+
+template<class L> struct mp_size_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_size is not a list
+};
+
+template<template<class...> class L, class... T> struct mp_size_impl<L<T...>>
+{
+    using type = mp_size_t<sizeof...(T)>;
+};
+
+} // namespace detail
+
+template<class L> using mp_size = typename detail::mp_size_impl<L>::type;
+
+// mp_empty<L>
+template<class L> using mp_empty = mp_bool< mp_size<L>::value == 0 >;
+
+// mp_assign<L1, L2>
+namespace detail
+{
+
+template<class L1, class L2> struct mp_assign_impl;
+
+template<template<class...> class L1, class... T, template<class...> class L2, class... U> struct mp_assign_impl<L1<T...>, L2<U...>>
+{
+    using type = L1<U...>;
+};
+
+} // namespace detail
+
+template<class L1, class L2> using mp_assign = typename detail::mp_assign_impl<L1, L2>::type;
+
+// mp_clear<L>
+template<class L> using mp_clear = mp_assign<L, mp_list<>>;
+
+// mp_front<L>
+//   in detail/mp_front.hpp
+
+// mp_pop_front<L>
+namespace detail
+{
+
+template<class L> struct mp_pop_front_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_pop_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class T1, class... T> struct mp_pop_front_impl<L<T1, T...>>
+{
+    using type = L<T...>;
+};
+
+} // namespace detail
+
+template<class L> using mp_pop_front = typename detail::mp_pop_front_impl<L>::type;
+
+// mp_first<L>
+template<class L> using mp_first = mp_front<L>;
+
+// mp_rest<L>
+template<class L> using mp_rest = mp_pop_front<L>;
+
+// mp_second<L>
+namespace detail
+{
+
+template<class L> struct mp_second_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class T1, class T2, class... T> struct mp_second_impl<L<T1, T2, T...>>
+{
+    using type = T2;
+};
+
+} // namespace detail
+
+template<class L> using mp_second = typename detail::mp_second_impl<L>::type;
+
+// mp_third<L>
+namespace detail
+{
+
+template<class L> struct mp_third_impl
+{
+// An error "no type named 'type'" here means that the argument to mp_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class T1, class T2, class T3, class... T> struct mp_third_impl<L<T1, T2, T3, T...>>
+{
+    using type = T3;
+};
+
+} // namespace detail
+
+template<class L> using mp_third = typename detail::mp_third_impl<L>::type;
+
+// mp_push_front<L, T...>
+namespace detail
+{
+
+template<class L, class... T> struct mp_push_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_push_front is not a list
+};
+
+template<template<class...> class L, class... U, class... T> struct mp_push_front_impl<L<U...>, T...>
+{
+    using type = L<T..., U...>;
+};
+
+} // namespace detail
+
+template<class L, class... T> using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;
+
+// mp_push_back<L, T...>
+namespace detail
+{
+
+template<class L, class... T> struct mp_push_back_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_push_back is not a list
+};
+
+template<template<class...> class L, class... U, class... T> struct mp_push_back_impl<L<U...>, T...>
+{
+    using type = L<U..., T...>;
+};
+
+} // namespace detail
+
+template<class L, class... T> using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
+
+// mp_rename<L, B>
+// mp_apply<F, L>
+// mp_apply_q<Q, L>
+//   in detail/mp_rename.hpp
+
+// mp_replace_front<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class U1, class... U, class T> struct mp_replace_front_impl<L<U1, U...>, T>
+{
+    using type = L<T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_first<L, T>
+template<class L, class T> using mp_replace_first = typename detail::mp_replace_front_impl<L, T>::type;
+
+// mp_replace_second<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_second_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class U1, class U2, class... U, class T> struct mp_replace_second_impl<L<U1, U2, U...>, T>
+{
+    using type = L<U1, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;
+
+// mp_replace_third<L, T>
+namespace detail
+{
+
+template<class L, class T> struct mp_replace_third_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_replace_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class U1, class U2, class U3, class... U, class T> struct mp_replace_third_impl<L<U1, U2, U3, U...>, T>
+{
+    using type = L<U1, U2, T, U...>;
+};
+
+} // namespace detail
+
+template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;
+
+// mp_transform_front<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_front_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_front
+// is either not a list, or is an empty list
+};
+
+template<template<class...> class L, class U1, class... U, template<class...> class F> struct mp_transform_front_impl<L<U1, U...>, F>
+{
+    using type = L<F<U1>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_front = typename detail::mp_transform_front_impl<L, F>::type;
+template<class L, class Q> using mp_transform_front_q = mp_transform_front<L, Q::template fn>;
+
+// mp_transform_first<L, F>
+template<class L, template<class...> class F> using mp_transform_first = typename detail::mp_transform_front_impl<L, F>::type;
+template<class L, class Q> using mp_transform_first_q = mp_transform_first<L, Q::template fn>;
+
+// mp_transform_second<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_second_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_second
+// is either not a list, or has fewer than two elements
+};
+
+template<template<class...> class L, class U1, class U2, class... U, template<class...> class F> struct mp_transform_second_impl<L<U1, U2, U...>, F>
+{
+    using type = L<U1, F<U2>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_second = typename detail::mp_transform_second_impl<L, F>::type;
+template<class L, class Q> using mp_transform_second_q = mp_transform_second<L, Q::template fn>;
+
+// mp_transform_third<L, F>
+namespace detail
+{
+
+template<class L, template<class...> class F> struct mp_transform_third_impl
+{
+// An error "no type named 'type'" here means that the first argument to mp_transform_third
+// is either not a list, or has fewer than three elements
+};
+
+template<template<class...> class L, class U1, class U2, class U3, class... U, template<class...> class F> struct mp_transform_third_impl<L<U1, U2, U3, U...>, F>
+{
+    using type = L<U1, U2, F<U3>, U...>;
+};
+
+} // namespace detail
+
+template<class L, template<class...> class F> using mp_transform_third = typename detail::mp_transform_third_impl<L, F>::type;
+template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q::template fn>;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_LIST_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/map.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/map.hpp
new file mode 100644
index 0000000000..b9581ac922
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/map.hpp
@@ -0,0 +1,119 @@
+#ifndef BOOST_MP11_MAP_HPP_INCLUDED
+#define BOOST_MP11_MAP_HPP_INCLUDED
+
+//  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/detail/mp_map_find.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/mp11/integral.hpp>
+#include <boost/mp11/utility.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/set.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_map_contains<M, K>
+template<class M, class K> using mp_map_contains = mp_not<std::is_same<mp_map_find<M, K>, void>>;
+
+// mp_map_insert<M, T>
+template<class M, class T> using mp_map_insert = mp_if< mp_map_contains<M, mp_first<T>>, M, mp_push_back<M, T> >;
+
+// mp_map_replace<M, T>
+namespace detail
+{
+
+template<class M, class T> struct mp_map_replace_impl;
+
+template<template<class...> class M, class... U, class T> struct mp_map_replace_impl<M<U...>, T>
+{
+    using K = mp_first<T>;
+
+    // mp_replace_if is inlined here using a struct _f because of msvc-14.0
+
+    template<class V> struct _f { using type = mp_if< std::is_same<mp_first<V>, K>, T, V >; };
+
+    using type = mp_if< mp_map_contains<M<U...>, K>, M<typename _f<U>::type...>, M<U..., T> >;
+};
+
+} // namespace detail
+
+template<class M, class T> using mp_map_replace = typename detail::mp_map_replace_impl<M, T>::type;
+
+// mp_map_update<M, T, F>
+namespace detail
+{
+
+template<class M, class T, template<class...> class F> struct mp_map_update_impl
+{
+    template<class U> using _f = std::is_same<mp_first<T>, mp_first<U>>;
+
+    // _f3<L<X, Y...>> -> L<X, F<X, Y...>>
+    template<class L> using _f3 = mp_assign<L, mp_list<mp_first<L>, mp_rename<L, F> > >;
+
+    using type = mp_if< mp_map_contains<M, mp_first<T>>, mp_transform_if<_f, _f3, M>, mp_push_back<M, T> >;
+};
+
+} // namespace detail
+
+template<class M, class T, template<class...> class F> using mp_map_update = typename detail::mp_map_update_impl<M, T, F>::type;
+template<class M, class T, class Q> using mp_map_update_q = mp_map_update<M, T, Q::template fn>;
+
+// mp_map_erase<M, K>
+namespace detail
+{
+
+template<class M, class K> struct mp_map_erase_impl
+{
+    template<class T> using _f = std::is_same<mp_first<T>, K>;
+    using type = mp_remove_if<M, _f>;
+};
+
+} // namespace detail
+
+template<class M, class K> using mp_map_erase = typename detail::mp_map_erase_impl<M, K>::type;
+
+// mp_map_keys<M>
+template<class M> using mp_map_keys = mp_transform<mp_first, M>;
+
+// mp_is_map<M>
+namespace detail
+{
+
+template<class L> struct mp_is_map_element: mp_false
+{
+};
+
+template<template<class...> class L, class T1, class... T> struct mp_is_map_element<L<T1, T...>>: mp_true
+{
+};
+
+template<class M> using mp_keys_are_set = mp_is_set<mp_map_keys<M>>;
+
+template<class M> struct mp_is_map_impl
+{
+    using type = mp_false;
+};
+
+template<template<class...> class M, class... T> struct mp_is_map_impl<M<T...>>
+{
+    using type = mp_eval_if<mp_not<mp_all<mp_is_map_element<T>...>>, mp_false, mp_keys_are_set, M<T...>>;
+};
+
+} // namespace detail
+
+template<class M> using mp_is_map = typename detail::mp_is_map_impl<M>::type;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_MAP_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/mpl.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/mpl.hpp
new file mode 100644
index 0000000000..994705ffc4
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/mpl.hpp
@@ -0,0 +1,14 @@
+#ifndef BOOST_MP11_MPL_HPP_INCLUDED
+#define BOOST_MP11_MPL_HPP_INCLUDED
+
+// 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/mpl_tuple.hpp>
+
+#endif // #ifndef BOOST_MP11_MPL_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/mpl_list.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/mpl_list.hpp
new file mode 100644
index 0000000000..643da43a08
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/mpl_list.hpp
@@ -0,0 +1,28 @@
+#ifndef BOOST_MP11_MPL_LIST_HPP_INCLUDED
+#define BOOST_MP11_MPL_LIST_HPP_INCLUDED
+
+// 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/detail/mpl_common.hpp>
+
+namespace boost
+{
+namespace mpl
+{
+
+template< typename Sequence > struct sequence_tag;
+
+template<class... T> struct sequence_tag<mp11::mp_list<T...>>
+{
+    using type = aux::mp11_tag;
+};
+
+} // namespace mpl
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_MPL_LIST_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/mpl_tuple.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/mpl_tuple.hpp
new file mode 100644
index 0000000000..b6900b1cd4
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/mpl_tuple.hpp
@@ -0,0 +1,29 @@
+#ifndef BOOST_MP11_MPL_TUPLE_HPP_INCLUDED
+#define BOOST_MP11_MPL_TUPLE_HPP_INCLUDED
+
+// 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/detail/mpl_common.hpp>
+#include <tuple>
+
+namespace boost
+{
+namespace mpl
+{
+
+template< typename Sequence > struct sequence_tag;
+
+template<class... T> struct sequence_tag<std::tuple<T...>>
+{
+    using type = aux::mp11_tag;
+};
+
+} // namespace mpl
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_MPL_TUPLE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/set.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/set.hpp
new file mode 100644
index 0000000000..808636b72b
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/set.hpp
@@ -0,0 +1,188 @@
+#ifndef BOOST_MP11_SET_HPP_INCLUDED
+#define BOOST_MP11_SET_HPP_INCLUDED
+
+// 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/mp11/utility.hpp>
+#include <boost/mp11/function.hpp>
+#include <boost/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_append.hpp>
+#include <boost/mp11/detail/mp_copy_if.hpp>
+#include <boost/mp11/detail/mp_remove_if.hpp>
+#include <boost/mp11/detail/mp_is_list.hpp>
+#include <type_traits>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_set_contains<S, V>
+namespace detail
+{
+
+template<class S, class V> struct mp_set_contains_impl
+{
+};
+
+template<template<class...> class L, class... T, class V> struct mp_set_contains_impl<L<T...>, V>
+{
+    using type = mp_to_bool<std::is_base_of<mp_identity<V>, mp_inherit<mp_identity<T>...> > >;
+};
+
+} // namespace detail
+
+template<class S, class V> using mp_set_contains = typename detail::mp_set_contains_impl<S, V>::type;
+
+// mp_set_push_back<S, T...>
+namespace detail
+{
+
+template<class S, class... T> struct mp_set_push_back_impl
+{
+};
+
+template<template<class...> class L, class... U> struct mp_set_push_back_impl<L<U...>>
+{
+    using type = L<U...>;
+};
+
+template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_back_impl<L<U...>, T1, T...>
+{
+    using S = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<U..., T1>>;
+    using type = typename mp_set_push_back_impl<S, T...>::type;
+};
+
+} // namespace detail
+
+template<class S, class... T> using mp_set_push_back = typename detail::mp_set_push_back_impl<S, T...>::type;
+
+// mp_set_push_front<S, T...>
+namespace detail
+{
+
+template<class S, class... T> struct mp_set_push_front_impl
+{
+};
+
+template<template<class...> class L, class... U> struct mp_set_push_front_impl<L<U...>>
+{
+    using type = L<U...>;
+};
+
+template<template<class...> class L, class... U, class T1> struct mp_set_push_front_impl<L<U...>, T1>
+{
+    using type = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<T1, U...>>;
+};
+
+template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_front_impl<L<U...>, T1, T...>
+{
+    using S = typename mp_set_push_front_impl<L<U...>, T...>::type;
+    using type = typename mp_set_push_front_impl<S, T1>::type;
+};
+
+} // namespace detail
+
+template<class S, class... T> using mp_set_push_front = typename detail::mp_set_push_front_impl<S, T...>::type;
+
+// mp_is_set<S>
+namespace detail
+{
+
+template<class S> struct mp_is_set_impl
+{
+    using type = mp_false;
+};
+
+template<template<class...> class L, class... T> struct mp_is_set_impl<L<T...>>
+{
+    using type = mp_to_bool<std::is_same<mp_list<T...>, mp_set_push_back<mp_list<>, T...> > >;
+};
+
+} // namespace detail
+
+template<class S> using mp_is_set = typename detail::mp_is_set_impl<S>::type;
+
+// mp_set_union<L...>
+namespace detail
+{
+
+template<class... L> struct mp_set_union_impl
+{
+};
+
+template<> struct mp_set_union_impl<>
+{
+    using type = mp_list<>;
+};
+
+template<template<class...> class L, class... T> struct mp_set_union_impl<L<T...>>
+{
+    using type = L<T...>;
+};
+
+template<template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_set_union_impl<L1<T1...>, L2<T2...>>
+{
+    using type = mp_set_push_back<L1<T1...>, T2...>;
+};
+
+template<class L1, class... L> using mp_set_union_ = typename mp_set_union_impl<L1, mp_append<mp_list<>, L...>>::type;
+
+template<class L1, class L2, class L3, class... L> struct mp_set_union_impl<L1, L2, L3, L...>: mp_defer<mp_set_union_, L1, L2, L3, L...>
+{
+};
+
+} // namespace detail
+
+template<class... L> using mp_set_union = typename detail::mp_set_union_impl<L...>::type;
+
+// mp_set_intersection<S...>
+namespace detail
+{
+
+template<class... S> struct in_all_sets
+{
+    template<class T> using fn = mp_all< mp_set_contains<S, T>... >;
+};
+
+template<class L, class... S> using mp_set_intersection_ = mp_if< mp_all<mp_is_list<S>...>, mp_copy_if_q<L, detail::in_all_sets<S...>> >;
+
+template<class... S> struct mp_set_intersection_impl
+{
+};
+
+template<> struct mp_set_intersection_impl<>
+{
+    using type = mp_list<>;
+};
+
+template<class L, class... S> struct mp_set_intersection_impl<L, S...>: mp_defer<mp_set_intersection_, L, S...>
+{
+};
+
+} // namespace detail
+
+template<class... S> using mp_set_intersection = typename detail::mp_set_intersection_impl<S...>::type;
+
+// mp_set_difference<L, S...>
+namespace detail
+{
+
+template<class... S> struct in_any_set
+{
+    template<class T> using fn = mp_any< mp_set_contains<S, T>... >;
+};
+
+} // namespace detail
+
+template<class L, class... S> using mp_set_difference = mp_if< mp_all<mp_is_list<S>...>, mp_remove_if_q<L, detail::in_any_set<S...>> >;
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_SET_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp
new file mode 100644
index 0000000000..fbab4a30f9
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/utility.hpp
@@ -0,0 +1,263 @@
+#ifndef BOOST_MP11_UTILITY_HPP_INCLUDED
+#define BOOST_MP11_UTILITY_HPP_INCLUDED
+
+// Copyright 2015-2020 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/mp11/detail/mp_list.hpp>
+#include <boost/mp11/detail/mp_fold.hpp>
+#include <boost/mp11/detail/mp_front.hpp>
+#include <boost/mp11/detail/mp_rename.hpp>
+#include <boost/mp11/detail/config.hpp>
+
+namespace boost
+{
+namespace mp11
+{
+
+// mp_identity
+template<class T> struct mp_identity
+{
+    using type = T;
+};
+
+// mp_identity_t
+template<class T> using mp_identity_t = typename mp_identity<T>::type;
+
+// mp_inherit
+template<class... T> struct mp_inherit: T... {};
+
+// mp_if, mp_if_c
+namespace detail
+{
+
+template<bool C, class T, class... E> struct mp_if_c_impl
+{
+};
+
+template<class T, class... E> struct mp_if_c_impl<true, T, E...>
+{
+    using type = T;
+};
+
+template<class T, class E> struct mp_if_c_impl<false, T, E>
+{
+    using type = E;
+};
+
+} // namespace detail
+
+template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
+template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
+
+// mp_valid
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_INTEL, != 0 ) // tested at 1800
+
+// contributed by Roland Schulz in https://github.com/boostorg/mp11/issues/17
+
+namespace detail
+{
+
+template<class...> using void_t = void;
+
+template<class, template<class...> class F, class... T>
+struct mp_valid_impl: mp_false {};
+
+template<template<class...> class F, class... T>
+struct mp_valid_impl<void_t<F<T...>>, F, T...>: mp_true {};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<void, F, T...>;
+
+#else
+
+// implementation by Bruno Dutra (by the name is_evaluable)
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_valid_impl
+{
+    template<template<class...> class G, class = G<T...>> static mp_true check(int);
+    template<template<class...> class> static mp_false check(...);
+
+    using type = decltype(check<F>(0));
+};
+
+} // namespace detail
+
+template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;
+
+#endif
+
+template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;
+
+// mp_defer
+namespace detail
+{
+
+template<template<class...> class F, class... T> struct mp_defer_impl
+{
+    using type = F<T...>;
+};
+
+struct mp_no_type
+{
+};
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> struct mp_defer_cuda_workaround
+{
+    using type = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+};
+
+#endif
+
+} // namespace detail
+
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_CUDA, >= 9000000 && BOOST_MP11_CUDA < 10000000 )
+
+template<template<class...> class F, class... T> using mp_defer = typename detail::mp_defer_cuda_workaround< F, T...>::type;
+
+#else
+
+template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;
+
+#endif
+
+// mp_eval_if, mp_eval_if_c
+namespace detail
+{
+
+template<bool C, class T, template<class...> class F, class... U> struct mp_eval_if_c_impl;
+
+template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<true, T, F, U...>
+{
+    using type = T;
+};
+
+template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<false, T, F, U...>: mp_defer<F, U...>
+{
+};
+
+} // namespace detail
+
+template<bool C, class T, template<class...> class F, class... U> using mp_eval_if_c = typename detail::mp_eval_if_c_impl<C, T, F, U...>::type;
+template<class C, class T, template<class...> class F, class... U> using mp_eval_if = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, F, U...>::type;
+template<class C, class T, class Q, class... U> using mp_eval_if_q = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, Q::template fn, U...>::type;
+
+// mp_eval_if_not
+template<class C, class T, template<class...> class F, class... U> using mp_eval_if_not = mp_eval_if<mp_not<C>, T, F, U...>;
+template<class C, class T, class Q, class... U> using mp_eval_if_not_q = mp_eval_if<mp_not<C>, T, Q::template fn, U...>;
+
+// mp_eval_or
+template<class T, template<class...> class F, class... U> using mp_eval_or = mp_eval_if_not<mp_valid<F, U...>, T, F, U...>;
+template<class T, class Q, class... U> using mp_eval_or_q = mp_eval_or<T, Q::template fn, U...>;
+
+// mp_valid_and_true
+template<template<class...> class F, class... T> using mp_valid_and_true = mp_eval_or<mp_false, F, T...>;
+template<class Q, class... T> using mp_valid_and_true_q = mp_valid_and_true<Q::template fn, T...>;
+
+// mp_cond
+
+// so elegant; so doesn't work
+// template<class C, class T, class... E> using mp_cond = mp_eval_if<C, T, mp_cond, E...>;
+
+namespace detail
+{
+
+template<class C, class T, class... E> struct mp_cond_impl;
+
+} // namespace detail
+
+template<class C, class T, class... E> using mp_cond = typename detail::mp_cond_impl<C, T, E...>::type;
+
+namespace detail
+{
+
+template<class C, class T, class... E> using mp_cond_ = mp_eval_if<C, T, mp_cond, E...>;
+
+template<class C, class T, class... E> struct mp_cond_impl: mp_defer<mp_cond_, C, T, E...>
+{
+};
+
+} // namespace detail
+
+// mp_quote
+template<template<class...> class F> struct mp_quote
+{
+    // the indirection through mp_defer works around the language inability
+    // to expand T... into a fixed parameter list of an alias template
+
+    template<class... T> using fn = typename mp_defer<F, T...>::type;
+};
+
+// mp_quote_trait
+template<template<class...> class F> struct mp_quote_trait
+{
+    template<class... T> using fn = typename F<T...>::type;
+};
+
+// mp_invoke_q
+#if BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+namespace detail
+{
+
+template<class Q, class... T> struct mp_invoke_q_impl: mp_defer<Q::template fn, T...> {};
+
+} // namespace detail
+
+template<class Q, class... T> using mp_invoke_q = typename detail::mp_invoke_q_impl<Q, T...>::type;
+
+#elif BOOST_MP11_WORKAROUND( BOOST_MP11_GCC, < 50000 )
+
+template<class Q, class... T> using mp_invoke_q = typename mp_defer<Q::template fn, T...>::type;
+
+#else
+
+template<class Q, class... T> using mp_invoke_q = typename Q::template fn<T...>;
+
+#endif
+
+// mp_not_fn<P>
+template<template<class...> class P> struct mp_not_fn
+{
+    template<class... T> using fn = mp_not< mp_invoke_q<mp_quote<P>, T...> >;
+};
+
+template<class Q> using mp_not_fn_q = mp_not_fn<Q::template fn>;
+
+// mp_compose
+namespace detail
+{
+
+template<class L, class Q> using mp_compose_helper = mp_list< mp_apply_q<Q, L> >;
+
+} // namespace detail
+
+#if !BOOST_MP11_WORKAROUND( BOOST_MP11_MSVC, < 1900 )
+
+template<template<class...> class... F> struct mp_compose
+{
+    template<class... T> using fn = mp_front< mp_fold<mp_list<mp_quote<F>...>, mp_list<T...>, detail::mp_compose_helper> >;
+};
+
+#endif
+
+template<class... Q> struct mp_compose_q
+{
+    template<class... T> using fn = mp_front< mp_fold<mp_list<Q...>, mp_list<T...>, detail::mp_compose_helper> >;
+};
+
+} // namespace mp11
+} // namespace boost
+
+#endif // #ifndef BOOST_MP11_UTILITY_HPP_INCLUDED
diff --git a/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp b/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp
new file mode 100644
index 0000000000..5a4be574ff
--- /dev/null
+++ b/contrib/restricted/boost/mp11/include/boost/mp11/version.hpp
@@ -0,0 +1,16 @@
+#ifndef BOOST_MP11_VERSION_HPP_INCLUDED
+#define BOOST_MP11_VERSION_HPP_INCLUDED
+
+//  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
+
+// Same format as BOOST_VERSION:
+//   major * 100000 + minor * 100 + patch
+
+#define BOOST_MP11_VERSION 108000
+
+#endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/type_erasure/builtin.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/builtin.hpp
index 7af5d84b23..7af5d84b23 100644
--- a/contrib/restricted/boost/boost/type_erasure/builtin.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/builtin.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/call.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/call.hpp
index 8234862cae..8234862cae 100644
--- a/contrib/restricted/boost/boost/type_erasure/call.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/call.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/check_match.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/check_match.hpp
index 837aadf022..3066a6fcac 100644
--- a/contrib/restricted/boost/boost/type_erasure/check_match.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/check_match.hpp
@@ -10,10 +10,6 @@
 
 #if !defined(BOOST_PP_IS_ITERATING)
 
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
 #ifndef BOOST_TYPE_ERASURE_CHECK_MATCH_HPP_INCLUDED
 #define BOOST_TYPE_ERASURE_CHECK_MATCH_HPP_INCLUDED
 
@@ -238,6 +234,7 @@ BOOST_PP_CAT(check_table, N)(
     R (*)(BOOST_PP_ENUM_PARAMS(N, T))
     BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, const U, &arg))
 {
+    (void)t;
     BOOST_PP_REPEAT(N, BOOST_TYPE_ERASURE_CHECK_TABLE, ~)
     return true;
 }
diff --git a/contrib/restricted/boost/boost/type_erasure/concept_interface.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/concept_interface.hpp
index ec054cd423..ec054cd423 100644
--- a/contrib/restricted/boost/boost/type_erasure/concept_interface.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/concept_interface.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/concept_of.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/concept_of.hpp
index f4b12dc743..f4b12dc743 100644
--- a/contrib/restricted/boost/boost/type_erasure/concept_of.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/concept_of.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/config.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/config.hpp
index 65cf127570..65cf127570 100644
--- a/contrib/restricted/boost/boost/type_erasure/config.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/config.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/constructible.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/constructible.hpp
index dd3c0f0004..dd3c0f0004 100644
--- a/contrib/restricted/boost/boost/type_erasure/constructible.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/constructible.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/deduced.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/deduced.hpp
index 966c29bfc0..966c29bfc0 100644
--- a/contrib/restricted/boost/boost/type_erasure/deduced.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/deduced.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/access.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/access.hpp
index 84c61931bb..84c61931bb 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/access.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/access.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/adapt_to_vtable.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/adapt_to_vtable.hpp
index f842dc3985..f842dc3985 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/adapt_to_vtable.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/adapt_to_vtable.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/any_base.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/any_base.hpp
index b7c4f8c050..b7c4f8c050 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/any_base.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/any_base.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/auto_link.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/auto_link.hpp
index 4f4392044b..4f4392044b 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/auto_link.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/auto_link.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/check_call.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/check_call.hpp
index daa9931146..daa9931146 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/check_call.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/check_call.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/check_map.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/check_map.hpp
index d39b61fba2..d39b61fba2 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/check_map.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/check_map.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/extract_concept.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/extract_concept.hpp
index 0b1ce5d2fa..0b1ce5d2fa 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/extract_concept.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/extract_concept.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/get_placeholders.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/get_placeholders.hpp
index a17d2d445c..a17d2d445c 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/get_placeholders.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/get_placeholders.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/get_signature.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/get_signature.hpp
index 066638b3fa..066638b3fa 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/get_signature.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/get_signature.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/meta.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/meta.hpp
index bae43c00f4..04db6d3526 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/meta.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/meta.hpp
@@ -13,8 +13,7 @@
 
 #include <boost/config.hpp>
 
-// disable BOOST_TYPE_ERASURE_USE_MP11, mail code conflicts when use both boost/fusion and boost/type_erasure
-#if 0
+
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
     !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) && \
     /* MSVC 14.0 breaks down in the template alias quagmire. */ \
@@ -27,7 +26,12 @@
 #include <boost/mp11/set.hpp>
 #include <boost/mp11/algorithm.hpp>
 #include <boost/mp11/function.hpp>
+
+#ifdef YA_BOOST_TYPE_ERASURE_FUSION_COMPAT
+#include <boost/mp11/mpl_list.hpp>
+#else
 #include <boost/mp11/mpl.hpp>
+#endif
 
 namespace boost {
 namespace type_erasure {
@@ -87,6 +91,4 @@ using first = T0;
 
 #endif
 
-#endif //if 0
-
 #endif
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/normalize.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/normalize.hpp
index 02c232a612..02c232a612 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/normalize.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/normalize.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/normalize_deduced.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/normalize_deduced.hpp
index dcf3fd3625..dcf3fd3625 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/normalize_deduced.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/normalize_deduced.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/rebind_placeholders.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/rebind_placeholders.hpp
index 0d0ef7c8e4..0d0ef7c8e4 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/rebind_placeholders.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/rebind_placeholders.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/detail/storage.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/storage.hpp
index 8e572871f3..8e572871f3 100644
--- a/contrib/restricted/boost/boost/type_erasure/detail/storage.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/detail/storage.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/exception.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/exception.hpp
index 68fb23e12a..68fb23e12a 100644
--- a/contrib/restricted/boost/boost/type_erasure/exception.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/exception.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/is_placeholder.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/is_placeholder.hpp
index a1e67fc165..a1e67fc165 100644
--- a/contrib/restricted/boost/boost/type_erasure/is_placeholder.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/is_placeholder.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/param.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/param.hpp
index 7aca5e3c6b..7aca5e3c6b 100644
--- a/contrib/restricted/boost/boost/type_erasure/param.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/param.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/placeholder.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/placeholder.hpp
index 1311f03bae..1311f03bae 100644
--- a/contrib/restricted/boost/boost/type_erasure/placeholder.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/placeholder.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/placeholder_of.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/placeholder_of.hpp
index 4a42b5744d..4a42b5744d 100644
--- a/contrib/restricted/boost/boost/type_erasure/placeholder_of.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/placeholder_of.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/rebind_any.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/rebind_any.hpp
index be62cff723..be62cff723 100644
--- a/contrib/restricted/boost/boost/type_erasure/rebind_any.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/rebind_any.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/register_binding.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/register_binding.hpp
index b0489b3ef0..b0489b3ef0 100644
--- a/contrib/restricted/boost/boost/type_erasure/register_binding.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/register_binding.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/relaxed.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/relaxed.hpp
index a9ada91df6..a9ada91df6 100644
--- a/contrib/restricted/boost/boost/type_erasure/relaxed.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/relaxed.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/require_match.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/require_match.hpp
index 8da4c6b827..8da4c6b827 100644
--- a/contrib/restricted/boost/boost/type_erasure/require_match.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/require_match.hpp
diff --git a/contrib/restricted/boost/boost/type_erasure/static_binding.hpp b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/static_binding.hpp
index 371ac62e4c..371ac62e4c 100644
--- a/contrib/restricted/boost/boost/type_erasure/static_binding.hpp
+++ b/contrib/restricted/boost/type_erasure/include/boost/type_erasure/static_binding.hpp
diff --git a/contrib/restricted/boost/type_erasure/src/dynamic_binding.cpp b/contrib/restricted/boost/type_erasure/src/dynamic_binding.cpp
new file mode 100644
index 0000000000..77c5909358
--- /dev/null
+++ b/contrib/restricted/boost/type_erasure/src/dynamic_binding.cpp
@@ -0,0 +1,57 @@
+// Boost.TypeErasure library
+//
+// Copyright 2015 Steven Watanabe
+//
+// 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)
+//
+// $Id$
+
+#define BOOST_TYPE_ERASURE_SOURCE
+
+#include <boost/type_erasure/register_binding.hpp>
+#include <boost/thread/shared_mutex.hpp>
+#include <boost/thread/lock_types.hpp>
+#include <map>
+#include <utility>
+
+namespace {
+    
+using ::boost::type_erasure::detail::key_type;
+using ::boost::type_erasure::detail::value_type;
+
+typedef ::std::map<key_type, void(*)()> map_type;
+typedef ::boost::shared_mutex mutex_type;
+
+// std::pair can have problems on older implementations
+// when it tries to use the copy constructor of the mutex.
+struct data_type
+{
+    map_type first;
+    mutex_type second;
+};
+
+data_type * get_data() {
+    static data_type result;
+    return &result;
+}
+
+}
+
+BOOST_TYPE_ERASURE_DECL void boost::type_erasure::detail::register_function_impl(const key_type& key, value_type fn) {
+    ::data_type * data = ::get_data();
+    ::boost::unique_lock<mutex_type> lock(data->second);
+    data->first.insert(std::make_pair(key, fn));
+}
+
+BOOST_TYPE_ERASURE_DECL value_type boost::type_erasure::detail::lookup_function_impl(const key_type& key) {
+    ::data_type * data = ::get_data();
+    ::boost::shared_lock<mutex_type> lock(data->second);
+    ::map_type::const_iterator pos = data->first.find(key);
+    if(pos != data->first.end()) {
+        return pos->second;
+    } else {
+        throw bad_any_cast();
+    }
+}