Reimport boost/ptr_container as a separate project

45 files changed, 33 insertions, 8271 deletions

diff --git a/contrib/restricted/boost/CMakeLists.txt b/contrib/restricted/boost/CMakeLists.txt
index 7c10a66e18..1d562b09c4 100644
--- a/contrib/restricted/boost/CMakeLists.txt
+++ b/contrib/restricted/boost/CMakeLists.txt
@@ -62,6 +62,7 @@ add_subdirectory(predef)
 add_subdirectory(preprocessor)
 add_subdirectory(program_options)
 add_subdirectory(proto)
+add_subdirectory(ptr_container)
 add_subdirectory(qvm)
 add_subdirectory(random)
 add_subdirectory(range)
@@ -137,6 +138,7 @@ target_link_libraries(contrib-restricted-boost INTERFACE
   restricted-boost-predef
   restricted-boost-preprocessor
   restricted-boost-proto
+  restricted-boost-ptr_container
   restricted-boost-qvm
   restricted-boost-random
   restricted-boost-range
diff --git a/contrib/restricted/boost/boost/ptr_container/clone_allocator.hpp b/contrib/restricted/boost/boost/ptr_container/clone_allocator.hpp
deleted file mode 100644
index cca885c74c..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/clone_allocator.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_CLONE_ALLOCATOR_HPP
-#define BOOST_PTR_CONTAINER_CLONE_ALLOCATOR_HPP
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <typeinfo>
-
-namespace boost
-{
-    /////////////////////////////////////////////////////////////////////////
-    // Clonable concept 
-    /////////////////////////////////////////////////////////////////////////
-    
-    template< class T >
-    inline T* new_clone( const T& r )
-    {
-        //
-        // @remark: if you get a compile-error here,
-        //          it is most likely because you did not
-        //          define new_clone( const T& ) in the namespace
-        //          of T.
-        //
-        T* res = new T( r );
-        BOOST_ASSERT( typeid(r) == typeid(*res) &&
-                      "Default new_clone() sliced object!" );
-        return res;
-    }
-
-
-    
-    template< class T >
-    inline void delete_clone( const T* r )
-    {
-        checked_delete( r );
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // CloneAllocator concept
-    /////////////////////////////////////////////////////////////////////////
-    
-    struct heap_clone_allocator
-    {
-        template< class U >
-        static U* allocate_clone( const U& r )
-        {
-            return new_clone( r );
-        }
-
-        template< class U >
-        static void deallocate_clone( const U* r )
-        {
-            delete_clone( r );
-        }
-
-    };
-
-
-    
-    struct view_clone_allocator
-    {
-        template< class U >
-        static U* allocate_clone( const U& r )
-        {
-            return const_cast<U*>(&r);
-        }
-
-        template< class U >
-        static void deallocate_clone( const U* /*r*/ )
-        {
-            // do nothing
-        }
-    };
-
-} // namespace 'boost'
-
-#endif
-
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/associative_ptr_container.hpp b/contrib/restricted/boost/boost/ptr_container/detail/associative_ptr_container.hpp
deleted file mode 100644
index a170fb727d..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/associative_ptr_container.hpp
+++ /dev/null
@@ -1,438 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-namespace ptr_container_detail
-{
-    template
-    <
-        class Config,
-        class CloneAllocator
-    >
-    class associative_ptr_container :
-        public reversible_ptr_container<Config,CloneAllocator>
-    {
-        typedef reversible_ptr_container<Config,CloneAllocator>
-                                base_type;
-
-        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
-                                scoped_deleter;
-
-        typedef BOOST_DEDUCED_TYPENAME Config::container_type
-                                container_type;
-    public: // typedefs
-        typedef BOOST_DEDUCED_TYPENAME Config::key_type
-                                key_type;
-        typedef BOOST_DEDUCED_TYPENAME Config::key_compare
-                                key_compare;
-        typedef BOOST_DEDUCED_TYPENAME Config::value_compare
-                                value_compare;
-        typedef BOOST_DEDUCED_TYPENAME Config::hasher
-                                hasher;
-        typedef BOOST_DEDUCED_TYPENAME Config::key_equal
-                                key_equal;
-        typedef BOOST_DEDUCED_TYPENAME Config::iterator
-                                iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
-                                const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::local_iterator
-                                local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::const_local_iterator
-                                const_local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                                size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference
-                                reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_reference;
-
-    public: // foundation
-        associative_ptr_container()
-        { }
-
-        template< class SizeType >
-        associative_ptr_container( SizeType n, unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Compare, class Allocator >
-        associative_ptr_container( const Compare& comp,
-                                   const Allocator& a )
-         : base_type( comp, a, container_type() )
-        { }
-        
-        template< class Hash, class Pred, class Allocator >
-        associative_ptr_container( const Hash& hash,
-                                   const Pred& pred,
-                                   const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        associative_ptr_container( InputIterator first, InputIterator last,
-                                   const Compare& comp,
-                                   const Allocator& a )
-         : base_type( first, last, comp, a, container_type() )
-        { }
-        
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        associative_ptr_container( InputIterator first, InputIterator last,
-                                   const Hash& hash,
-                                   const Pred& pred,
-                                   const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
-         : base_type( r )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit associative_ptr_container( std::unique_ptr<PtrContainer> r )
-         : base_type( std::move( r ) )
-        { }
-#endif
-
-        associative_ptr_container( const associative_ptr_container& r )
-         : base_type( r.begin(), r.end(), container_type() )
-        { }
-        
-        template< class C, class V >
-        associative_ptr_container( const associative_ptr_container<C,V>& r )
-         : base_type( r.begin(), r.end(), container_type() )
-        { }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
-        {
-           base_type::operator=( r );
-           return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        associative_ptr_container& operator=( std::unique_ptr<PtrContainer> r ) // nothrow
-        {
-           base_type::operator=( std::move( r ) );
-           return *this;
-        }
-#endif
-        
-        associative_ptr_container& operator=( associative_ptr_container r ) // strong
-        {
-           this->swap( r );
-           return *this;   
-        }
-
-    public: // associative container interface
-        key_compare key_comp() const
-        {
-            return this->base().key_comp();
-        }
-
-        value_compare value_comp() const
-        {
-            return this->base().value_comp();
-        }
-
-        iterator erase( iterator before ) // nothrow
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( before != this->end() );
-
-            this->remove( before );                      // nothrow
-            iterator res( before );                      // nothrow
-            ++res;                                       // nothrow
-            this->base().erase( before.base() );         // nothrow
-            return res;                                  // nothrow
-        }
-
-        size_type erase( const key_type& x ) // nothrow
-        {
-            iterator i( this->base().find( x ) );       
-                                                        // nothrow
-            if( i == this->end() )                      // nothrow
-                return 0u;                              // nothrow
-            this->remove( i );                          // nothrow
-            return this->base().erase( x );             // nothrow 
-        }
-
-        iterator erase( iterator first,
-                        iterator last ) // nothrow
-        {
-            iterator res( last );                                // nothrow
-            if( res != this->end() )
-                ++res;                                           // nothrow
-
-            this->remove( first, last );                         // nothrow
-            this->base().erase( first.base(), last.base() );     // nothrow
-            return res;                                          // nothrow
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_convertible<Range&,key_type&>, 
-                                                  iterator >::type
-        erase( const Range& r )
-        {
-            return erase( boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-    protected:
-
-        template< class AssociatePtrCont >
-        void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
-                             AssociatePtrCont& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
-
-            this->base().insert( *object.base() );     // strong
-            from.base().erase( object.base() );        // nothrow
-        }
-
-        template< class AssociatePtrCont >
-        size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
-                                  BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
-                                  AssociatePtrCont& from ) // basic
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
- 
-            size_type res = 0;
-            for( ; first != last; )
-            {
-                BOOST_ASSERT( first != from.end() );
-                this->base().insert( *first.base() );     // strong
-                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
-                    to_delete( first );
-                ++first;
-                from.base().erase( to_delete.base() );    // nothrow
-                ++res;
-            }
-
-            return res;
-        }
-
-        template< class AssociatePtrCont >
-        bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
-                              AssociatePtrCont& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
-
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
-                this->base().insert( *object.base() );     // strong
-            if( p.second )
-                from.base().erase( object.base() );        // nothrow
-
-            return p.second;
-        }
-
-        template< class AssociatePtrCont >
-        size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
-                                   BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
-                                   AssociatePtrCont& from ) // basic
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-
-            size_type res = 0;
-            for( ; first != last; )
-            {
-                BOOST_ASSERT( first != from.end() );
-                std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
-                    this->base().insert( *first.base() );     // strong
-                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
-                    to_delete( first );
-                ++first;
-                if( p.second )
-                {
-                    from.base().erase( to_delete.base() );   // nothrow
-                    ++res;
-                }
-            }
-            return res;
-        }
-        
-        reference front()
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( *this->begin().base() != 0 );
-            return *this->begin(); 
-        }
-
-        const_reference front() const
-        {
-            return const_cast<associative_ptr_container*>(this)->front();
-        }
-
-        reference back()
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( *(--this->end()).base() != 0 );
-            return *--this->end(); 
-        }
-
-        const_reference back() const
-        {
-            return const_cast<associative_ptr_container*>(this)->back();
-        }
-
-    protected: // unordered interface
-        hasher hash_function() const
-        {
-            return this->base().hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return this->base().key_eq();
-        }
-        
-        size_type bucket_count() const
-        {
-            return this->base().bucket_count();
-        }
-        
-        size_type max_bucket_count() const
-        {
-            return this->base().max_bucket_count();
-        }
-        
-        size_type bucket_size( size_type n ) const
-        {
-            return this->base().bucket_size( n );
-        }
-        
-        float load_factor() const
-        {
-            return this->base().load_factor();
-        }
-        
-        float max_load_factor() const
-        {
-            return this->base().max_load_factor();
-        }
-        
-        void max_load_factor( float factor )
-        {
-            return this->base().max_load_factor( factor );
-        }
-        
-        void rehash( size_type n )
-        {
-            this->base().rehash( n );
-        }
-
-    public:
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(70190006))
-        iterator begin()
-        {
-            return base_type::begin();
-        }
-
-        const_iterator begin() const
-        {
-            return base_type::begin();
-        }
-
-        iterator end()
-        {
-            return base_type::end();
-        }
-
-        const_iterator end() const
-        {
-            return base_type::end();
-        }
-
-        const_iterator cbegin() const
-        {
-            return base_type::cbegin();
-        }
-
-        const_iterator cend() const
-        {
-            return base_type::cend();
-        }
-#else
-         using base_type::begin;
-         using base_type::end;
-         using base_type::cbegin;
-         using base_type::cend;
-#endif
-
-    protected:
-        local_iterator begin( size_type n )
-        {
-            return local_iterator( this->base().begin( n ) );
-        }
-        
-        const_local_iterator begin( size_type n ) const
-        {
-            return const_local_iterator( this->base().begin( n ) );
-        }
-        
-        local_iterator end( size_type n )
-        {
-            return local_iterator( this->base().end( n ) );
-        }
-        
-        const_local_iterator end( size_type n ) const
-        {
-            return const_local_iterator( this->base().end( n ) );
-        }
-        
-        const_local_iterator cbegin( size_type n ) const
-        {
-            return const_local_iterator( this->base().cbegin( n ) );
-        }
-        
-        const_local_iterator cend( size_type n )
-        {
-            return const_local_iterator( this->base().cend( n ) );
-        }
-
-     }; // class 'associative_ptr_container'
-    
-} // namespace 'ptr_container_detail'
-    
-} // namespace 'boost'
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/default_deleter.hpp b/contrib/restricted/boost/boost/ptr_container/detail/default_deleter.hpp
deleted file mode 100644
index 2ded7cf3dd..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/default_deleter.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// (C) Copyright Jonathan Turkanis 2004-2005.
-// 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.)
-
-// Contains the definition of move_ptrs::default_deleter, the default
-// Deleter template argument to move_ptr. Uses a technique of Daniel
-// Wallin to capture the type of a pointer at the time the deleter 
-// is constructed, so that move_ptrs can delete objects of incomplete 
-// type by default.
-
-#ifndef BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED
-#define BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED 
-
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
-#include <boost/checked_delete.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/remove_bounds.hpp>
-
-namespace boost { namespace ptr_container_detail { namespace move_ptrs {
-
-namespace ptr_container_detail {
-
-template<typename T>
-struct deleter_base {
-    typedef void (*deleter)(T*);
-    deleter_base(deleter d) { delete_ = d; }
-    void operator() (T* t) const { delete_(t); }
-    static deleter delete_;
-};
-
-template<class T>
-typename deleter_base<T>::deleter 
-deleter_base<T>::delete_;
-
-template<typename T>
-struct scalar_deleter : deleter_base<T> {
-    typedef deleter_base<T> base;
-    scalar_deleter() : base(do_delete) { }
-    static void do_delete(T* t) { checked_delete(t); }
-};
-
-template<typename T>
-struct array_deleter 
-    : deleter_base<typename remove_bounds<T>::type>
-{
-    typedef typename remove_bounds<T>::type element_type;
-    typedef deleter_base<element_type> base;
-    array_deleter() : base(do_delete) { }
-    static void do_delete(element_type* t) { checked_array_delete(t); }
-};
-
-} // End namespace ptr_container_detail.
-
-template<typename T>
-struct default_deleter
-    : mpl::if_<
-          is_array<T>,
-          ptr_container_detail::array_deleter<T>,
-          ptr_container_detail::scalar_deleter<T>
-      >::type
-{ 
-    default_deleter() { }
-    template<typename TT>
-    default_deleter(default_deleter<TT>) { }
-};
-
-} } } // End namespaces ptr_container_detail, move_ptrs, boost.
-
-#endif // #ifndef BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/is_convertible.hpp b/contrib/restricted/boost/boost/ptr_container/detail/is_convertible.hpp
deleted file mode 100644
index fd17781925..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/is_convertible.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// (C) Copyright Thorsten Ottosen 2005
-// (C) Copyright Howard Hinnant 2004
-// (C) Copyright Jonathan Turkanis 2004
-// 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.)
-
-//
-// Contains type traits machinery for incomplete arrays. MPL compatibility
-// is included for completeness, but is not necessary for the current 
-// application.
-// 
-
-#ifndef BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
-#define BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
-
-#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_bounds.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/utility/enable_if.hpp>
-
-namespace boost { namespace ptr_container_detail { namespace move_ptrs {
-
-// From Howard Hinnant.
-template<typename T, typename U>
-struct is_array_convertible {
-    typedef typename remove_bounds<T>::type      t_element; 
-    typedef typename remove_bounds<U>::type      u_element; 
-    typedef typename remove_cv<t_element>::type  t_base; 
-    typedef typename remove_cv<u_element>::type  u_base; 
-    typedef typename 
-            mpl::and_<
-                is_array<T>,
-                is_array<U>,
-                is_same<t_base, u_base>,
-                is_convertible<t_element*, u_element*>
-            >::type                                     type;
-    BOOST_STATIC_CONSTANT(bool, value = type::value);
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, is_array_convertible, (T, U))
-};
-
-template<typename T, typename U>
-struct is_smart_ptr_convertible 
-    : mpl::if_<
-          is_array<T>,
-          is_array_convertible<T, U>,
-          is_convertible<T*, U*> 
-      >::type
-    { };
-
-#ifndef BOOST_NO_SFINAE
-    template<typename Src, typename Tgt, typename T = void>
-    struct enable_if_convertible 
-        : enable_if< 
-              is_smart_ptr_convertible<Src, Tgt>,
-              T
-          >
-        { };
-#else
-    template<typename Src, typename Tgt, class T >
-    struct enable_if_convertible : mpl::identity<T> { };
-#endif
-
-} } }         // End namespaces ptr_container_detail, move_ptrs, boost.
-
-#endif      // #ifndef BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/map_iterator.hpp b/contrib/restricted/boost/boost/ptr_container/detail/map_iterator.hpp
deleted file mode 100644
index 518ba217d9..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/map_iterator.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP
-#define BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/utility/compare_pointees.hpp>
-#include <utility>
-
-#if defined(BOOST_MSVC)  
-# pragma warning(push)  
-# pragma warning(disable:4512)    // Assignment operator could not be generated.  
-#endif 
-
-namespace boost
-{ 
-    namespace ptr_container_detail
-    {
-        template< class F, class S >
-        struct ref_pair
-        {
-            typedef F first_type;
-            typedef S second_type;
-
-            const F& first;
-            S        second;
-
-            template< class F2, class S2 >
-            ref_pair( const std::pair<F2,S2>& p )
-            : first(p.first), second(static_cast<S>(p.second))
-            { }
-
-            template< class RP >
-            ref_pair( const RP* rp )
-            : first(rp->first), second(rp->second)
-            { }
-
-            const ref_pair* operator->() const
-            {
-                return this;
-            }
-
-            friend inline bool operator==( ref_pair l, ref_pair r )
-            {
-                return l.first == r.first && 
-                       boost::equal_pointees( l.second, r.second );
-            }
-
-            friend inline bool operator!=( ref_pair l, ref_pair r )
-            {
-                return !( l == r );
-            }
-
-            friend inline bool operator<( ref_pair l, ref_pair r )
-            {
-                if( l.first == r.first )
-                    return boost::less_pointees( l.second, r.second );
-                else 
-                    return l.first < r.first;
-            }
-
-            friend inline bool operator>( ref_pair l, ref_pair r )
-            {
-                return r < l;
-            }
-
-            friend inline bool operator<=( ref_pair l, ref_pair r )
-            {
-                return !(r < l);
-            }
-
-            friend inline bool operator>=( ref_pair l, ref_pair r )
-            {
-                return !(l < r);
-            }
-
-        };
-    }
-    
-    template< 
-              class I, // base iterator 
-              class F, // first type, key type
-              class S  // second type, mapped type
-            > 
-    class ptr_map_iterator : 
-        public boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 
-                                        ptr_container_detail::ref_pair<F,S>, 
-                                        use_default, 
-                                        ptr_container_detail::ref_pair<F,S> >
-    {
-        typedef boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 
-                                         ptr_container_detail::ref_pair<F,S>,
-                                         use_default, 
-                                         ptr_container_detail::ref_pair<F,S> > 
-            base_type;
-
-
-    public:
-        ptr_map_iterator() : base_type()                                 
-        { }
-        
-        explicit ptr_map_iterator( const I& i ) : base_type(i)
-        { }
-
-        template< class I2, class F2, class S2 >
-            ptr_map_iterator( const ptr_map_iterator<I2,F2,S2>& r ) 
-         : base_type(r.base())
-        { }
-        
-   }; // class 'ptr_map_iterator'
-
-}
-
-#if defined(BOOST_MSVC)  
-# pragma warning(pop)  
-#endif 
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/meta_functions.hpp b/contrib/restricted/boost/boost/ptr_container/detail/meta_functions.hpp
deleted file mode 100644
index 16ceb44ee1..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/meta_functions.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_META_FUNCTIONS
-#define BOOST_PTR_CONTAINER_DETAIL_META_FUNCTIONS
-
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/eval_if.hpp>
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-    template< class T >
-    struct select_value_compare
-    {
-        typedef typename T::value_compare type;
-    };
-
-    template< class T >
-    struct select_key_compare
-    {
-        typedef typename T::key_compare type;
-    };
-
-    template< class T >
-    struct select_hasher
-    {
-        typedef typename T::hasher type;
-    };
-
-    template< class T >
-    struct select_key_equal
-    {
-        typedef typename T::key_equal type;
-    };
-
-    template< class T >
-    struct select_iterator
-    {
-        typedef typename T::iterator type;
-    };
-    
-    template< class T >
-    struct select_local_iterator
-    {
-        typedef typename T::local_iterator type;
-    };
-
-    template< class T >
-    struct select_const_local_iterator
-    {
-        typedef typename T::const_local_iterator type;
-    };
-}
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/move.hpp b/contrib/restricted/boost/boost/ptr_container/detail/move.hpp
deleted file mode 100644
index bf07d5f563..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/move.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// (C) Copyright Daniel Wallin 2004.
-// 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.)
-
-// Contains the definitions of the class template move_source and the function
-// template move, which together make move pointers moveable.
-
-#ifndef BOOST_MOVE_HPP_INCLUDED
-#define BOOST_MOVE_HPP_INCLUDED
-
-namespace boost { namespace ptr_container_detail {
-
-namespace move_ptrs {
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)    
-#pragma warning(push)    
-#pragma warning(disable:4512)  
-#endif  
-    
-template<typename Ptr>
-class move_source {
-public:
-    move_source(Ptr& ptr) : ptr_(ptr) {}
-    Ptr& ptr() const { return ptr_; }
-private:
-    Ptr& ptr_;
-    move_source(const Ptr&);
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)    
-#pragma warning(pop)    
-#endif  
-
-} // End namespace move_ptrs.
-
-
-template<typename T>
-move_ptrs::move_source<T> move(T& x) 
-{ return move_ptrs::move_source<T>(x); }
-
-} // namespace 'ptr_container_detail'
-} // End namespace boost.
-
-#endif // #ifndef BOOST_MOVE_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/ptr_container_disable_deprecated.hpp b/contrib/restricted/boost/boost/ptr_container/detail/ptr_container_disable_deprecated.hpp
deleted file mode 100644
index 6aaa2c1629..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/ptr_container_disable_deprecated.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef BOOST_PTR_CONTAINER_DETAIL_PTR_CONTAINER_DISABLE_DEPRECATED_HPP_INCLUDED
-#define BOOST_PTR_CONTAINER_DETAIL_PTR_CONTAINER_DISABLE_DEPRECATED_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/ptr_container/detail/ptr_container_disable_deprecated.hpp
-//
-//  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/config.hpp>
-
-#if defined( __GNUC__ ) && ( defined( __GXX_EXPERIMENTAL_CXX0X__ ) || ( __cplusplus >= 201103L ) ) && !defined(BOOST_NO_AUTO_PTR)
-
-# if defined( BOOST_GCC )
-
-#  if BOOST_GCC >= 40600
-#   define BOOST_PTR_CONTAINER_DISABLE_DEPRECATED
-#  endif
-
-# elif defined( __clang__ ) && defined( __has_warning )
-
-#  if __has_warning( "-Wdeprecated-declarations" )
-#   define BOOST_PTR_CONTAINER_DISABLE_DEPRECATED
-#  endif
-
-# endif
-
-#endif
-
-#endif // #ifndef BOOST_PTR_CONTAINER_DETAIL_PTR_CONTAINER_DISABLE_DEPRECATED_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/reversible_ptr_container.hpp b/contrib/restricted/boost/boost/ptr_container/detail/reversible_ptr_container.hpp
deleted file mode 100644
index 37cb9bb57b..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/reversible_ptr_container.hpp
+++ /dev/null
@@ -1,866 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_REVERSIBLE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_REVERSIBLE_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/throw_exception.hpp>
-#include <boost/ptr_container/detail/scoped_deleter.hpp>
-#include <boost/ptr_container/detail/static_move_ptr.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <boost/ptr_container/exception.hpp>
-#include <boost/ptr_container/clone_allocator.hpp>
-#include <boost/ptr_container/nullable.hpp>
-
-#ifdef BOOST_NO_SFINAE
-#else
-#include <boost/range/functions.hpp>
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/swap.hpp>
-#include <typeinfo>
-#include <memory>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(push)  
-#pragma warning(disable:4127)
-#pragma warning(disable:4224) // formal parameter was previously defined as a type.
-#endif  
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-namespace ptr_container_detail
-{
-    template< class Container >
-    struct dynamic_clone_deleter
-    {
-        dynamic_clone_deleter() { }
-        dynamic_clone_deleter( Container& cont ) : cont(&cont) { }
-        Container* cont;
-
-        template< class T >
-        void operator()( const T* p ) const
-        {
-            // remark: static_move_ptr already test for null
-            cont->get_clone_allocator().deallocate_clone( p );
-        }
-    };
-
-    template< class CloneAllocator >
-    struct static_clone_deleter
-    {
-        static_clone_deleter() { }
-        template< class Dummy >
-        static_clone_deleter( const Dummy& ) { }
-            
-        template< class T >
-        void operator()( const T* p ) const
-        {
-            // remark: static_move_ptr already test for null
-            CloneAllocator::deallocate_clone( p );
-        }
-    };
-
-    template< class T >
-    struct is_pointer_or_integral
-    {
-        BOOST_STATIC_CONSTANT(bool, value = is_pointer<T>::value || is_integral<T>::value );
-    };
-
-    struct is_pointer_or_integral_tag {};
-    struct is_range_tag {};
-    struct sequence_tag {};
-    struct fixed_length_sequence_tag : sequence_tag {};
-    struct associative_container_tag {};
-    struct ordered_associative_container_tag : associative_container_tag {};
-    struct unordered_associative_container_tag : associative_container_tag {};
-    
-
-    
-    template
-    < 
-        class Config, 
-        class CloneAllocator
-    >
-    class reversible_ptr_container : CloneAllocator
-    {
-    private:
-        BOOST_STATIC_CONSTANT( bool, allow_null = Config::allow_null );
-        BOOST_STATIC_CONSTANT( bool, is_clone_allocator_empty = sizeof(CloneAllocator) < sizeof(void*) );
-
-        typedef BOOST_DEDUCED_TYPENAME Config::value_type Ty_;
-        typedef BOOST_DEDUCED_TYPENAME Config::void_container_type  container_type;
-        typedef dynamic_clone_deleter<reversible_ptr_container>     dynamic_deleter_type;
-        typedef static_clone_deleter<CloneAllocator>                static_deleter_type;
-        
-        container_type c_;
-
-    public:
-        container_type&       base()               { return c_; }
-    protected: // having this public could break encapsulation
-        const container_type& base() const         { return c_; }        
-        
-    public: // typedefs
-        typedef  Ty_           object_type;
-        typedef  Ty_*          value_type;
-        typedef  Ty_*          pointer;
-        typedef  Ty_&          reference;
-        typedef  const Ty_&    const_reference;
-        
-        typedef  BOOST_DEDUCED_TYPENAME Config::iterator 
-                                   iterator;
-        typedef  BOOST_DEDUCED_TYPENAME Config::const_iterator
-                                   const_iterator;
-        typedef  boost::reverse_iterator< iterator > 
-                                   reverse_iterator;  
-        typedef  boost::reverse_iterator< const_iterator >     
-                                   const_reverse_iterator;
-        typedef  BOOST_DEDUCED_TYPENAME container_type::difference_type
-                                   difference_type; 
-        typedef  BOOST_DEDUCED_TYPENAME container_type::size_type
-                                   size_type;
-        typedef  BOOST_DEDUCED_TYPENAME Config::allocator_type
-                                   allocator_type;
-        typedef CloneAllocator     clone_allocator_type;
-        typedef ptr_container_detail::static_move_ptr<Ty_, 
-                     BOOST_DEDUCED_TYPENAME boost::mpl::if_c<is_clone_allocator_empty,
-                                                                static_deleter_type,
-                                                                dynamic_deleter_type>::type 
-                                                     >
-                                   auto_type;
-            
-    protected: 
-            
-        typedef ptr_container_detail::scoped_deleter<reversible_ptr_container>
-                                   scoped_deleter;
-        typedef BOOST_DEDUCED_TYPENAME container_type::iterator
-                                   ptr_iterator; 
-        typedef BOOST_DEDUCED_TYPENAME container_type::const_iterator
-                                   ptr_const_iterator; 
-    private:
-
-        template< class InputIterator >  
-        void copy( InputIterator first, InputIterator last ) 
-        {
-            std::copy( first, last, begin() );
-        }
-        
-        void copy( const reversible_ptr_container& r )
-        { 
-            this->copy( r.begin(), r.end() );
-        }
-        
-        void copy_clones_and_release( scoped_deleter& sd ) // nothrow
-        {
-            BOOST_ASSERT( size_type( std::distance( sd.begin(), sd.end() ) ) == c_.size() );
-            std::copy( sd.begin(), sd.end(), c_.begin() );
-            sd.release(); 
-        }
-        
-        template< class ForwardIterator >
-        void clone_assign( ForwardIterator first, 
-                           ForwardIterator last ) // strong 
-        {
-            BOOST_ASSERT( first != last );
-            scoped_deleter sd( *this, first, last ); // strong
-            copy_clones_and_release( sd );           // nothrow
-        }
-
-        template< class ForwardIterator >
-        void clone_back_insert( ForwardIterator first,
-                                ForwardIterator last )
-        {
-            BOOST_ASSERT( first != last );
-            scoped_deleter sd( *this, first, last );
-            insert_clones_and_release( sd, end() );
-        }
-        
-        void remove_all() 
-        {
-            this->remove( begin(), end() ); 
-        }
-
-    protected:
-
-        void insert_clones_and_release( scoped_deleter& sd, 
-                                        iterator where ) // strong
-        {
-            //
-            // 'c_.insert' always provides the strong guarantee for T* elements
-            // since a copy constructor of a pointer cannot throw
-            //
-            c_.insert( where.base(), 
-                       sd.begin(), sd.end() ); 
-            sd.release();
-        }
-
-        void insert_clones_and_release( scoped_deleter& sd ) // strong
-        {
-            c_.insert( sd.begin(), sd.end() );
-            sd.release();
-        }
-
-        template< class U >
-        void remove( U* ptr )
-        {
-            this->deallocate_clone( ptr );
-        }
-        
-        template< class I >
-        void remove( I i )
-        { 
-            this->deallocate_clone( Config::get_const_pointer(i) );
-        }
-
-        template< class I >
-        void remove( I first, I last ) 
-        {
-            for( ; first != last; ++first )
-                this->remove( first );
-        }
-
-        static void enforce_null_policy( const Ty_* x, const char* msg )
-        {
-            if( !allow_null )
-            {
-                BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed", 
-                                                     bad_pointer, msg );
-            }
-        }
-
-    public:
-        Ty_* null_policy_allocate_clone( const Ty_* x )
-        {
-            if( allow_null )
-            {
-                if( x == 0 )
-                    return 0;
-            }
-            else
-            {
-                BOOST_ASSERT( x != 0 && "Cannot insert clone of null!" );
-            }
-
-            Ty_* res = this->get_clone_allocator().allocate_clone( *x );
-            BOOST_ASSERT( typeid(*res) == typeid(*x) &&
-                          "CloneAllocator::allocate_clone() does not clone the "
-                          "object properly. Check that new_clone() is implemented"
-                          " correctly" );
-            return res;
-        }
-
-        template< class Iterator >
-        Ty_* null_policy_allocate_clone_from_iterator( Iterator i )
-        {
-            return this->null_policy_allocate_clone(Config::get_const_pointer(i));
-        }
-        
-        void null_policy_deallocate_clone( const Ty_* x )
-        {
-            if( allow_null )
-            {
-                if( x == 0 )
-                    return;
-            }
-
-            this->get_clone_allocator().deallocate_clone( x );
-        }
-        
-    private:
-        template< class ForwardIterator >
-        ForwardIterator advance( ForwardIterator begin, size_type n ) 
-        {
-            ForwardIterator iter = begin;
-            std::advance( iter, n );
-            return iter;
-        }        
-
-        template< class I >
-        void constructor_impl( I first, I last, std::input_iterator_tag ) // basic
-        {
-            while( first != last )
-            {
-                insert( end(), this->allocate_clone_from_iterator(first) );
-                ++first;
-            }
-        }
-
-        template< class I >
-        void constructor_impl( I first, I last, std::forward_iterator_tag ) // strong
-        {
-            if( first == last )
-                return;
-            clone_back_insert( first, last );
-        }
-
-        template< class I >
-        void associative_constructor_impl( I first, I last ) // strong
-        {
-            if( first == last )
-                return;
-
-            scoped_deleter sd( *this, first, last );
-            insert_clones_and_release( sd );             
-        }
-
-    public: // foundation: should be protected, but public for poor compilers' sake.
-        reversible_ptr_container()
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, unordered_associative_container_tag )
-          : c_( n )
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, fixed_length_sequence_tag )
-          : c_( n )
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, const allocator_type& a, 
-                                  fixed_length_sequence_tag )
-          : c_( n, a )
-        { }
-        
-        explicit reversible_ptr_container( const allocator_type& a ) 
-         : c_( a )
-        { }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit reversible_ptr_container( std::auto_ptr<PtrContainer> clone )
-        {
-            swap( *clone );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit reversible_ptr_container( std::unique_ptr<PtrContainer> clone )
-        {
-            swap( *clone );
-        }
-#endif
-
-        reversible_ptr_container( const reversible_ptr_container& r ) 
-        {
-            constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); 
-        }
-
-        template< class C, class V >
-        reversible_ptr_container( const reversible_ptr_container<C,V>& r ) 
-        {
-            constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); 
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        reversible_ptr_container& operator=( std::auto_ptr<PtrContainer> clone ) // nothrow
-        {
-            swap( *clone );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        reversible_ptr_container& operator=( std::unique_ptr<PtrContainer> clone ) // nothrow
-        {
-            swap( *clone );
-            return *this;
-        }
-#endif
-
-        reversible_ptr_container& operator=( reversible_ptr_container r ) // strong 
-        {
-            swap( r );
-            return *this;
-        }
-        
-        // overhead: null-initilization of container pointer (very cheap compared to cloning)
-        // overhead: 1 heap allocation (very cheap compared to cloning)
-        template< class InputIterator >
-        reversible_ptr_container( InputIterator first, 
-                                  InputIterator last,
-                                  const allocator_type& a = allocator_type() ) // basic, strong
-          : c_( a )
-        { 
-            constructor_impl( first, last, 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#else
-                              BOOST_DEDUCED_TYPENAME
-#endif                              
-                              iterator_category<InputIterator>::type() );
-        }
-
-        template< class Compare >
-        reversible_ptr_container( const Compare& comp,
-                                  const allocator_type& a )
-          : c_( comp, a ) {}
-
-        template< class ForwardIterator >
-        reversible_ptr_container( ForwardIterator first,
-                                  ForwardIterator last,
-                                  fixed_length_sequence_tag )
-          : c_( std::distance(first,last) )
-        {
-            constructor_impl( first, last, 
-                              std::forward_iterator_tag() );
-        }
-
-        template< class SizeType, class InputIterator >
-        reversible_ptr_container( SizeType n,
-                                  InputIterator first,
-                                  InputIterator last,
-                                  fixed_length_sequence_tag )
-          : c_( n )
-        {
-            constructor_impl( first, last, 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#else
-                              BOOST_DEDUCED_TYPENAME
-#endif                              
-                              iterator_category<InputIterator>::type() );
-        }
-
-        template< class Compare >
-        reversible_ptr_container( const Compare& comp,
-                                  const allocator_type& a,
-                                  associative_container_tag )
-          : c_( comp, a )
-        { }
-                
-        template< class InputIterator >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  associative_container_tag )
-        {
-            associative_constructor_impl( first, last );
-        }
-        
-        template< class InputIterator, class Compare >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  const Compare& comp,
-                                  const allocator_type& a,
-                                  associative_container_tag )
-          : c_( comp, a ) 
-        {
-            associative_constructor_impl( first, last );
-        }
-
-        explicit reversible_ptr_container( size_type n )
-          : c_( n ) {}
-
-        template< class Hash, class Pred >
-        reversible_ptr_container( const Hash& h,
-                                  const Pred& pred,
-                                  const allocator_type& a )
-          : c_( h, pred, a ) {}
-
-        template< class InputIterator, class Hash, class Pred >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  const Hash& h,
-                                  const Pred& pred,
-                                  const allocator_type& a )
-          : c_( h, pred, a )
-        {
-            associative_constructor_impl( first, last );
-        }
-
-    public:        
-        ~reversible_ptr_container()
-        { 
-            remove_all();
-        }
-        
-    public:
-        
-        allocator_type get_allocator() const                   
-        {
-            return c_.get_allocator(); 
-        }
-        
-        clone_allocator_type& get_clone_allocator()
-        {
-            return static_cast<clone_allocator_type&>(*this);
-        }
- 
-        const clone_allocator_type& get_clone_allocator() const
-        {
-            return static_cast<const clone_allocator_type&>(*this);
-        }
- 
-    public: // container requirements
-        iterator begin()            
-            { return iterator( c_.begin() ); }
-        const_iterator begin() const      
-            { return const_iterator( c_.begin() ); }
-        iterator end()              
-            { return iterator( c_.end() ); }
-        const_iterator end() const        
-            { return const_iterator( c_.end() ); }
-        
-        reverse_iterator rbegin()           
-            { return reverse_iterator( this->end() ); } 
-        const_reverse_iterator rbegin() const     
-            { return const_reverse_iterator( this->end() ); } 
-        reverse_iterator rend()             
-            { return reverse_iterator( this->begin() ); } 
-        const_reverse_iterator rend() const       
-            { return const_reverse_iterator( this->begin() ); } 
-
-        const_iterator cbegin() const      
-            { return const_iterator( c_.begin() ); }
-        const_iterator cend() const             
-            { return const_iterator( c_.end() ); }
-
-        const_reverse_iterator crbegin() const      
-            { return const_reverse_iterator( this->end() ); }
-        const_reverse_iterator crend() const             
-            { return const_reverse_iterator( this->begin() ); }
-
-        void swap( reversible_ptr_container& r ) // nothrow
-        { 
-            boost::swap( get_clone_allocator(), r.get_clone_allocator() ); // nothrow
-            c_.swap( r.c_ ); // nothrow
-        }
-          
-        size_type size() const // nothrow
-        {
-            return c_.size();
-        }
-
-        size_type max_size() const // nothrow
-        {
-            return c_.max_size(); 
-        }
-        
-        bool empty() const // nothrow
-        {
-            return c_.empty();
-        }
-
-    public: // optional container requirements
-
-        bool operator==( const reversible_ptr_container& r ) const // nothrow
-        { 
-            if( size() != r.size() )
-                return false;
-            else
-                return std::equal( begin(), end(), r.begin() );
-        }
-
-        bool operator!=( const reversible_ptr_container& r ) const // nothrow
-        {
-            return !(*this == r);
-        }
-        
-        bool operator<( const reversible_ptr_container& r ) const // nothrow 
-        {
-             return std::lexicographical_compare( begin(), end(), r.begin(), r.end() );
-        }
-
-        bool operator<=( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return !(r < *this);
-        }
-
-        bool operator>( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return r < *this;
-        }
-
-        bool operator>=( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return !(*this < r);
-        }
-
-    public: // modifiers
-
-        iterator insert( iterator before, Ty_* x )
-        {
-            enforce_null_policy( x, "Null pointer in 'insert()'" );
-
-            auto_type ptr( x, *this );                     // nothrow
-            iterator res( c_.insert( before.base(), x ) ); // strong, commit
-            ptr.release();                                 // nothrow
-            return res;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator before, std::auto_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator before, std::unique_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-#endif
-
-        iterator erase( iterator x ) // nothrow
-        {
-            BOOST_ASSERT( !empty() );
-            BOOST_ASSERT( x != end() );
-
-            remove( x );
-            return iterator( c_.erase( x.base() ) );
-        }
-
-        iterator erase( iterator first, iterator last ) // nothrow
-        {
-            remove( first, last );
-            return iterator( c_.erase( first.base(),
-                                       last.base() ) );
-        }
-
-        template< class Range >
-        iterator erase( const Range& r )
-        {
-            return erase( boost::begin(r), boost::end(r) );
-        }
-
-        void clear()
-        {
-            remove_all();
-            c_.clear();
-        }
-        
-    public: // access interface
-        
-        auto_type release( iterator where )
-        { 
-            BOOST_ASSERT( where != end() );
-            
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation,
-                                                 "'release()' on empty container" ); 
-            
-            auto_type ptr( Config::get_pointer(where), *this );  // nothrow
-            c_.erase( where.base() );                            // nothrow
-            return boost::ptr_container_detail::move( ptr ); 
-        }
-
-        auto_type replace( iterator where, Ty_* x ) // strong  
-        { 
-            BOOST_ASSERT( where != end() );
-            enforce_null_policy( x, "Null pointer in 'replace()'" );            
-
-            auto_type ptr( x, *this );
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation,
-                                                 "'replace()' on empty container" );
-
-            auto_type old( Config::get_pointer(where), *this );  // nothrow            
-            const_cast<void*&>(*where.base()) = ptr.release();                
-            return boost::ptr_container_detail::move( old );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        auto_type replace( iterator where, std::auto_ptr<U> x )
-        {
-            return replace( where, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        auto_type replace( iterator where, std::unique_ptr<U> x )
-        {
-            return replace( where, x.release() );
-        }
-#endif
-
-        auto_type replace( size_type idx, Ty_* x ) // strong
-        {
-            enforce_null_policy( x, "Null pointer in 'replace()'" );            
-
-            auto_type ptr( x, *this ); 
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= size(), bad_index, 
-                                                 "'replace()' out of bounds" );
-            
-            auto_type old( static_cast<Ty_*>(c_[idx]), *this ); // nothrow
-            c_[idx] = ptr.release();                            // nothrow, commit
-            return boost::ptr_container_detail::move( old );
-        } 
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        auto_type replace( size_type idx, std::auto_ptr<U> x )
-        {
-            return replace( idx, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        auto_type replace( size_type idx, std::unique_ptr<U> x )
-        {
-            return replace( idx, x.release() );
-        }
-#endif
-                
-    }; // 'reversible_ptr_container'
-
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \
-    typename base_type::auto_type                   \
-    release( typename base_type::iterator i )       \
-    {                                               \
-        return boost::ptr_container_detail::move(base_type::release(i)); \
-    }                                               
-#else
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \
-    using base_type::release;
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-#define BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_AUTO( PC, base_type, this_type ) \
-    explicit PC( std::auto_ptr<this_type> r )       \
-    : base_type ( r ) { }                           \
-                                                    \
-    PC& operator=( std::auto_ptr<this_type> r )     \
-    {                                               \
-        base_type::operator=( r );                  \
-        return *this;                               \
-    }
-#else
-#define BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_AUTO( PC, base_type, this_type )
-#endif
-
-#ifndef BOOST_NO_CXX11_SMART_PTR
-#define BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_UNIQUE( PC, base_type, this_type ) \
-    explicit PC( std::unique_ptr<this_type> r )     \
-    : base_type ( std::move( r ) ) { }              \
-                                                    \
-    PC& operator=( std::unique_ptr<this_type> r )   \
-    {                                               \
-        base_type::operator=( std::move( r ) );     \
-        return *this;                               \
-    }
-#else
-#define BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_UNIQUE( PC, base_type, this_type )
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-#define BOOST_PTR_CONTAINER_RELEASE_AND_CLONE( this_type ) \
-    std::auto_ptr<this_type> release()              \
-    {                                               \
-      std::auto_ptr<this_type> ptr( new this_type );\
-      this->swap( *ptr );                           \
-      return ptr;                                   \
-    }                                               \
-                                                    \
-    std::auto_ptr<this_type> clone() const          \
-    {                                               \
-       return std::auto_ptr<this_type>( new this_type( this->begin(), this->end() ) ); \
-    }
-#elif !defined( BOOST_NO_CXX11_SMART_PTR )
-#define BOOST_PTR_CONTAINER_RELEASE_AND_CLONE( this_type ) \
-    std::unique_ptr<this_type> release()              \
-    {                                                 \
-      std::unique_ptr<this_type> ptr( new this_type );\
-      this->swap( *ptr );                             \
-      return ptr;                                     \
-    }                                                 \
-                                                      \
-    std::unique_ptr<this_type> clone() const          \
-    {                                                 \
-       return std::unique_ptr<this_type>( new this_type( this->begin(), this->end() ) ); \
-    }
-#else
-#define BOOST_PTR_CONTAINER_RELEASE_AND_CLONE( this_type )
-#endif
-
-    //
-    // two-phase lookup of template functions
-    // is buggy on most compilers, so we use a macro instead
-    //
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )  \
-    BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_AUTO( PC, base_type, this_type )   \
-    BOOST_PTR_CONTAINER_COPY_AND_ASSIGN_UNIQUE( PC, base_type, this_type ) \
-    BOOST_PTR_CONTAINER_RELEASE_AND_CLONE( this_type )                     \
-    BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type )
-
-#define BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type ) \
-                                                                      \
-    template< class U >                                               \
-    PC( const PC<U>& r ) : base_type( r ) { }                         \
-                                                                      \
-    PC& operator=( PC r )                                             \
-    {                                                                 \
-        this->swap( r );                                              \
-        return *this;                                                 \
-    }                                                                 \
-                                                                           
-
-#define BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type )                       \
-    typedef BOOST_DEDUCED_TYPENAME base_type::iterator        iterator;                \
-    typedef BOOST_DEDUCED_TYPENAME base_type::size_type       size_type;               \
-    typedef BOOST_DEDUCED_TYPENAME base_type::const_reference const_reference;         \
-    typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type  allocator_type;          \
-    PC() {}                                                                            \
-    explicit PC( const allocator_type& a ) : base_type(a) {}                           \
-    template< class InputIterator >                                                    \
-    PC( InputIterator first, InputIterator last ) : base_type( first, last ) {}        \
-    template< class InputIterator >                                                    \
-    PC( InputIterator first, InputIterator last,                                       \
-        const allocator_type& a ) : base_type( first, last, a ) {}  
-                 
-#define BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type )           \
-   BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type )                                    \
-   BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )
-
-#define BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( PC, base_type, this_type )  \
-    BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type )  \
-    BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type )
-
-} // namespace 'ptr_container_detail'
-
-    //
-    // @remark: expose movability of internal move-pointer
-    //
-    namespace ptr_container
-    {        
-        using ptr_container_detail::move;
-    }
-
-} // namespace 'boost'  
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(pop)  
-#endif  
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/scoped_deleter.hpp b/contrib/restricted/boost/boost/ptr_container/detail/scoped_deleter.hpp
deleted file mode 100644
index 38bbea932e..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/scoped_deleter.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SCOPED_DELETER_HPP
-#define BOOST_PTR_CONTAINER_SCOPED_DELETER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <iterator>
-#include <cstddef>
-#include <boost/scoped_array.hpp>
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template< class Container >
-        class scoped_deleter
-        {
-            typedef BOOST_DEDUCED_TYPENAME Container::size_type   size_type;
-            typedef BOOST_DEDUCED_TYPENAME Container::object_type T;
-            
-            Container&        cont_;
-            scoped_array<T*>  ptrs_;
-            size_type         stored_; 
-            bool              released_;
-            
-        public:
-            scoped_deleter( Container& cont, T** a, size_type size ) 
-                : cont_(cont), 
-                  ptrs_( a ), 
-                  stored_( size ), 
-                  released_( false )
-            { 
-                BOOST_ASSERT( a );
-            }
-            
-            scoped_deleter( Container& cont, size_type size ) 
-                : cont_(cont), 
-                  ptrs_( new T*[size] ), 
-                  stored_( 0 ), 
-                  released_( false )
-            {
-                BOOST_ASSERT( size > 0 );
-            }
-
-
-            
-            scoped_deleter( Container& cont, size_type n, const T& x ) // strong
-                : cont_(cont), 
-                  ptrs_( new T*[n] ), 
-                  stored_(0),
-                  released_( false )
-            {
-                for( size_type i = 0; i != n; i++ )
-                    add( cont_.null_policy_allocate_clone( &x ) );
-                BOOST_ASSERT( stored_ > 0 );
-            }
-
-
-            
-            template< class InputIterator >
-            scoped_deleter ( Container& cont, InputIterator first, InputIterator last  ) // strong
-                : cont_(cont),
-                  ptrs_( new T*[ std::distance(first,last) ] ),
-                  stored_(0),
-                  released_( false )
-            {
-                for( ; first != last; ++first )
-                    add( cont_.null_policy_allocate_clone_from_iterator( first ) );
-                BOOST_ASSERT( stored_ > 0 );
-            }
-
-            
-            
-            ~scoped_deleter()
-            {
-                if ( !released_ )
-                {
-                    for( size_type i = 0u; i != stored_; ++i )
-                        cont_.null_policy_deallocate_clone( ptrs_[i] ); 
-                }
-            }
-            
-            
-            
-            void add( T* t )
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                ptrs_[stored_] = t;
-                ++stored_;
-            }
-            
-            
-            
-            void release()
-            {
-                released_ = true;
-            }
-            
-            
-            
-            T** begin()
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                return &ptrs_[0];
-            }
-            
-            
-            
-            T** end()
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                return &ptrs_[stored_];
-            }
-            
-        }; // class 'scoped_deleter'
-    }
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp b/contrib/restricted/boost/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp
deleted file mode 100644
index d0e93dfdcb..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_PTR_MAP_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_PTR_MAP_ADAPTER_HPP
-
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-#include <boost/ptr_container/detail/serialize_xml_names.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void save(Archive& ar, const ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::const_iterator const_iterator;
-
-    ar << boost::serialization::make_nvp( ptr_container_detail::count(), 
-                                          ptr_container_detail::serialize_as_const(c.size()) );
-
-    const_iterator i = c.begin(), e = c.end();
-    for(; i != e; ++i)
-    {
-        ar << boost::serialization::make_nvp( ptr_container_detail::first(), i->first );
-        ar << boost::serialization::make_nvp( ptr_container_detail::second(),
-                                              ptr_container_detail::serialize_as_const(i->second) );
-    }
-}
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void load(Archive& ar, ptr_map_adapter<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_map_adapter<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::key_type key_type;
-    typedef BOOST_DEDUCED_TYPENAME container::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container::iterator iterator;
-
-    c.clear();
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-
-    for(size_type i = 0u; i != n; ++i)
-    {
-        key_type key;
-        T* value;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::first(), key );
-        ar >> boost::serialization::make_nvp( ptr_container_detail::second(), value );
-        std::pair<iterator, bool> p = c.insert(key, value);
-        ar.reset_object_address(&p.first->first, &key); 
-    }
-}
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void load(Archive& ar, ptr_multimap_adapter<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_multimap_adapter<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::key_type key_type;
-    typedef BOOST_DEDUCED_TYPENAME container::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container::iterator iterator;
-
-    c.clear();
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-
-    for(size_type i = 0u; i != n; ++i)
-    {
-        key_type key;
-        T* value;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::first(), key );
-        ar >> boost::serialization::make_nvp( ptr_container_detail::second(), value );
-        iterator p = c.insert(key, value);
-        ar.reset_object_address(&p->first, &key);
-    }
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/serialize_reversible_cont.hpp b/contrib/restricted/boost/boost/ptr_container/detail/serialize_reversible_cont.hpp
deleted file mode 100644
index 5aeddfea26..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/serialize_reversible_cont.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_REVERSIBLE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_REVERSIBLE_PTR_CONTAINER_HPP
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-#include <boost/ptr_container/detail/serialize_xml_names.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost 
-{
-
-namespace ptr_container_detail
-{
-
-template<class Archive, class Config, class CloneAllocator>
-void save_helper(Archive& ar, const ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME container_type::value_type value_type;
-
-    const_iterator i = c.begin(), e = c.end();
-    for(; i != e; ++i)
-        ar << boost::serialization::make_nvp( ptr_container_detail::item(), 
-                ptr_container_detail::serialize_as_const(static_cast<value_type>(*i.base()))); 
-    }
-
-template<class Archive, class Config, class CloneAllocator>
-void load_helper(Archive& ar, ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c,
-                 BOOST_DEDUCED_TYPENAME ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>::size_type n)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::value_type value_type;
-
-    //
-    // Called after an appropriate reserve on c.
-    //
-
-    c.clear();            
-    for(size_type i = 0u; i != n; ++i)
-    {
-        //
-        // Remark: pointers are not tracked,
-        // so we need not call ar.reset_object_address(v, u)
-        //
-        value_type ptr;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::item(), ptr ); 
-        c.insert(c.end(), ptr);
-    }
-}
-
-} // namespace ptr_container_detail
-
-namespace serialization 
-{
-
-template<class Archive, class Config, class CloneAllocator>
-void save(Archive& ar, const ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c, unsigned int /*version*/)
-{   
-    ar << boost::serialization::make_nvp( ptr_container_detail::count(), 
-                                          ptr_container_detail::serialize_as_const(c.size()) );
-    ptr_container_detail::save_helper(ar, c);
-}
-
-template<class Archive, class Config, class CloneAllocator>
-void load(Archive& ar, ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    ptr_container_detail::load_helper(ar, c, n);
-    
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/serialize_xml_names.hpp b/contrib/restricted/boost/boost/ptr_container/detail/serialize_xml_names.hpp
deleted file mode 100644
index d260198568..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/serialize_xml_names.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2007. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_XML_NAMES
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_XML_NAMES
-
-namespace boost
-{
-    namespace ptr_container_detail
-    {
-        inline const char* count()  { return "count"; }
-        inline const char* item()   { return "item"; }
-        inline const char* first()  { return "first"; }
-        inline const char* second() { return "second"; }
-
-        template<class T>
-        inline T const& serialize_as_const(T const& r)
-        {
-            return r;
-        }
-    }
-}
-#endif
-
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/static_move_ptr.hpp b/contrib/restricted/boost/boost/ptr_container/detail/static_move_ptr.hpp
deleted file mode 100644
index 2a89ca7803..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/static_move_ptr.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-// (C) Copyright Thorsten Ottosen 2005.
-// (C) Copyright Jonathan Turkanis 2004.
-// (C) Copyright Daniel Wallin 2004.
-// 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.)
-
-// Implementation of the move_ptr from the "Move Proposal" 
-// (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm) 
-// enhanced to support custom deleters and safe boolean conversions.
-//
-// The implementation is based on an implementation by Daniel Wallin, at
-// "http://aspn.activestate.com/ASPN/Mail/Message/Attachments/boost/
-// 400DC271.1060903@student.umu.se/move_ptr.hpp". The current was adapted 
-// by Jonathan Turkanis to incorporating ideas of Howard Hinnant and 
-// Rani Sharoni. 
-
-#ifndef BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
-#define BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
-
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
-#include <boost/config.hpp> // Member template friends, put size_t in std.
-#include <cstddef>          // size_t
-#include <boost/compressed_pair.hpp> 
-#include <boost/ptr_container/detail/default_deleter.hpp>       
-#include <boost/ptr_container/detail/is_convertible.hpp>       
-#include <boost/ptr_container/detail/move.hpp>       
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4521)        // Multiple copy constuctors.
-#endif
-
-namespace boost { namespace ptr_container_detail {
-
-    
-template< typename T, 
-          typename Deleter = 
-              move_ptrs::default_deleter<T> >
-class static_move_ptr 
-{
-public:
-
-    typedef typename remove_bounds<T>::type             element_type;
-    typedef Deleter                                     deleter_type;
-
-private:
-    
-    struct safe_bool_helper { int x; };
-    typedef int safe_bool_helper::* safe_bool;
-    typedef boost::compressed_pair<element_type*, Deleter> impl_type;
-
-public:
-    typedef typename impl_type::second_reference        deleter_reference;
-    typedef typename impl_type::second_const_reference  deleter_const_reference;
-
-        // Constructors
-
-    static_move_ptr() : impl_(0) { }
-
-    static_move_ptr(const static_move_ptr& p)
-        : impl_(p.get(), p.get_deleter())    
-        { 
-            const_cast<static_move_ptr&>(p).release();
-        }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-    static_move_ptr( const move_ptrs::move_source<static_move_ptr<T,Deleter> >& src )
-#else
-    static_move_ptr( const move_ptrs::move_source<static_move_ptr>& src )
-#endif    
-            : impl_(src.ptr().get(), src.ptr().get_deleter())
-            {
-                src.ptr().release();
-            }
-    
-    template<typename TT>
-    static_move_ptr(TT* tt, Deleter del) 
-        : impl_(tt, del) 
-        { }
-
-        // Destructor
-
-    ~static_move_ptr() { if (ptr()) get_deleter()(ptr()); }
-
-        // Assignment
-
-    static_move_ptr& operator=(static_move_ptr rhs)
-        {
-            rhs.swap(*this);
-            return *this;
-        }
-
-        // Smart pointer interface
-
-    element_type* get() const { return ptr(); }
-
-    element_type& operator*() 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return *ptr(); 
-        }
-
-    const element_type& operator*() const 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return *ptr(); 
-        }
-
-    element_type* operator->()  
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return ptr(); 
-        }    
-
-    const element_type* operator->() const 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return ptr(); 
-        }    
-
-
-    element_type* release()
-        {
-            element_type* result = ptr();
-            ptr() = 0;
-            return result;
-        }
-
-    void reset()
-        {
-            if (ptr()) get_deleter()(ptr());
-            ptr() = 0;
-        }
-
-    template<typename TT>
-    void reset(TT* tt, Deleter dd) 
-        {
-            static_move_ptr(tt, dd).swap(*this);
-        }
-
-    operator safe_bool() const { return ptr() ? &safe_bool_helper::x : 0; }
-
-    void swap(static_move_ptr& p) { impl_.swap(p.impl_); }
-
-    deleter_reference get_deleter() { return impl_.second(); }
-
-    deleter_const_reference get_deleter() const { return impl_.second(); }
-private:
-    template<typename TT, typename DD>
-    void check(const static_move_ptr<TT, DD>&)
-        {
-            typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
-            BOOST_STATIC_ASSERT(convertible::value);
-        }   
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_NO_SFINAE)
-// give up on this behavior
-#else 
-
-    template<typename Ptr> struct cant_move_from_const;
-
-    template<typename TT, typename DD> 
-    struct cant_move_from_const< const static_move_ptr<TT, DD> > { 
-        typedef typename static_move_ptr<TT, DD>::error type; 
-    };
-
-    template<typename Ptr> 
-    static_move_ptr(Ptr&, typename cant_move_from_const<Ptr>::type = 0);
-
-
-public:
-    static_move_ptr(static_move_ptr&);
-
-    
-private:
-    template<typename TT, typename DD>
-    static_move_ptr( static_move_ptr<TT, DD>&,
-                     typename 
-                     move_ptrs::enable_if_convertible<
-                         TT, T, static_move_ptr&
-                     >::type::type* = 0 );
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING || BOOST_NO_SFINAE
-
-//#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-//    template<typename TT, typename DD>
-//    friend class static_move_ptr;
-//#else
-    public:
-//#endif
-    typename impl_type::first_reference 
-    ptr() { return impl_.first(); } 
-
-    typename impl_type::first_const_reference 
-    ptr() const { return impl_.first(); }
-
-    impl_type impl_;
-};
-
-} // namespace ptr_container_detail
-} // End namespace boost.
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop) // #pragma warning(disable:4251)
-#endif
-
-#endif      // #ifndef BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/throw_exception.hpp b/contrib/restricted/boost/boost/ptr_container/detail/throw_exception.hpp
deleted file mode 100644
index bb467f2bd9..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/throw_exception.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2006. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION
-#define BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_EXCEPTIONS
-#define BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-#endif
-
-#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-
-#define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) BOOST_ASSERT( !(If) && Msg ) 
-
-#else
-
-#define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) if( (If) ) throw Ex ( Msg )
-
-#endif // BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/detail/void_ptr_iterator.hpp b/contrib/restricted/boost/boost/ptr_container/detail/void_ptr_iterator.hpp
deleted file mode 100644
index 5a96eb4719..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/detail/void_ptr_iterator.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_VOID_PTR_ITERATOR_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_VOID_PTR_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost
-{
-        template
-        < 
-            class VoidIter, 
-            class T
-        >
-        class void_ptr_iterator
-        {
-        public:
-            typedef BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type        
-                             value_type;
-            typedef T&       reference;
-            typedef T*       pointer;
-
-            typedef  BOOST_DEDUCED_TYPENAME iterator_difference<VoidIter>::type
-                             difference_type;           
-            typedef  BOOST_DEDUCED_TYPENAME iterator_category<VoidIter>::type
-                             iterator_category;           
-        private:
-
-            VoidIter iter_;
-
-        public:
-            void_ptr_iterator() : iter_()
-            { }
-
-            void_ptr_iterator( VoidIter r ) : iter_(r)
-            { }
-
-            //
-            // Remark: passing by value breaks vc7.1 
-            //
-            template< class MutableIterator, class MutableT >
-            void_ptr_iterator( const void_ptr_iterator<MutableIterator,MutableT>& r )
-#ifdef BOOST_NO_SFINAE
-                         : iter_( VoidIter(const_cast<void**>(&*r.base())) )
-#else
-
-             : iter_(r.base())
-#endif
-            { }
-
-            T& operator*() const
-            {
-                return *static_cast<T*>( *iter_ );
-            }
-
-            T* operator->() const
-            {
-                return static_cast<T*>( *iter_ );
-            }
-            
-            void_ptr_iterator& operator++()
-            {
-                ++iter_;
-                return *this;
-            }
-
-            void_ptr_iterator operator++(int)
-            {
-                void_ptr_iterator res = *this;
-                ++iter_;
-                return res;
-            }
-
-            void_ptr_iterator& operator--()
-            {
-                --iter_;
-                return *this;
-            }
-
-            void_ptr_iterator operator--(int)
-            {
-                void_ptr_iterator res = *this;
-                --iter_;
-                return res;
-            }
-
-            void_ptr_iterator& operator+=( difference_type n )
-            {
-                iter_ += n;
-                return *this;
-            }
-
-            void_ptr_iterator& operator-=( difference_type n )
-            {
-                iter_ -= n;
-                return *this;
-            }
-
-            T& operator[]( difference_type n ) const
-            {
-                return *static_cast<T*>( *(iter_ + n) );
-            }
-
-            VoidIter base() const
-            {
-                return iter_;
-            }
-
-        }; // class 'void_ptr_iterator'
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator+( void_ptr_iterator<VoidIter,T> l, 
-                   BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
-        {
-            l += n;
-            return l;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n, 
-                   void_ptr_iterator<VoidIter,T> r ) 
-
-        {
-            r += n;
-            return r;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator-( void_ptr_iterator<VoidIter,T> l, 
-                   BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
-        {
-            l -= n;
-            return l;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n, 
-                   void_ptr_iterator<VoidIter,T> r ) 
-
-        {
-            r -= n;
-            return r;
-        }
-
-
-        namespace ptr_container_detail
-        {
-            template<typename T, typename U>
-            struct is_compatible
-            {
-                static const bool value = boost::is_same< typename boost::remove_const<T>::type, typename boost::remove_const<U>::type >::value;
-            };
-        }
-
-          
-        template< class VoidIter, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type
-        >::type
-        operator-( void_ptr_iterator<VoidIter,T> l,
-                   void_ptr_iterator<VoidIterU,U> r ) 
-
-        {
-            return l.base() - r.base();
-        }
-
-
-
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator==( const void_ptr_iterator<VoidIterT,T>& l,
-                                const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() == r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator!=( const void_ptr_iterator<VoidIterT,T>& l,
-                                const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() != r.base();
-        }
-
-
-
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator<( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() < r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator<=( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() <= r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator>( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() > r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME boost::enable_if<
-            ptr_container_detail::is_compatible<T, U>,
-            bool
-        >::type
-        operator>=( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() >= r.base();
-        }
-
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/exception.hpp b/contrib/restricted/boost/boost/ptr_container/exception.hpp
deleted file mode 100644
index ed845737b5..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/exception.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_EXCEPTION_HPP
-#define BOOST_PTR_CONTAINER_EXCEPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <exception>
-
-namespace boost
-{
-    class bad_ptr_container_operation : public std::exception
-    {
-        const char* what_;
-    public:
-        bad_ptr_container_operation( const char* what ) : what_( what )
-        { }
-        
-        virtual const char* what() const noexcept
-        {
-            return what_;
-        }
-    };
-
-
-    
-    class bad_index : public bad_ptr_container_operation
-    {
-    public:
-        bad_index( const char* what ) : bad_ptr_container_operation( what )
-        { }
-    };
-
-
-
-    class bad_pointer : public bad_ptr_container_operation
-    {
-    public:
-        bad_pointer() : bad_ptr_container_operation( "Null pointer not allowed in a pointer container!" )
-        { }
-        
-        bad_pointer( const char* text ) : bad_ptr_container_operation( text )
-        { }
-    };
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/indirect_fun.hpp b/contrib/restricted/boost/boost/ptr_container/indirect_fun.hpp
deleted file mode 100644
index 0c5726509c..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/indirect_fun.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2007. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_INDIRECT_FUN_HPP
-#define BOOST_PTR_CONTAINER_INDIRECT_FUN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-    #pragma once
-#endif
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_SFINAE
-#else
-#include <boost/utility/result_of.hpp>
-#include <boost/pointee.hpp>
-#endif // BOOST_NO_SFINAE
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <functional>
-
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template <typename Type, typename Dummy>
-        struct make_lazy
-        {
-            typedef typename Type::type type;
-        };
-    }
-    
-    template
-    < 
-              class Fun
-#ifdef BOOST_NO_SFINAE
-            , class Result = bool
-#endif        
-    >
-    class indirect_fun
-    {
-        Fun fun;
-    public:
-        indirect_fun() : fun(Fun())
-        { }
-        
-        indirect_fun( Fun f ) : fun(f)
-        { }
-    
-        template< class T >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else            
-        typename boost::result_of< const Fun( typename pointee<T>::type& ) >::type 
-#endif            
-        operator()( const T& r ) const
-        { 
-            return fun( *r );
-        }
-    
-        template< class T, class U >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else                        
-        typename boost::result_of< const Fun( typename pointee<T>::type&,
-                                              typename pointee<U>::type& ) >::type
-#endif            
-        operator()( const T& r, const U& r2 ) const
-        { 
-            return fun( *r, *r2 ); 
-        }
-    };
-
-    template< class Fun >
-    inline indirect_fun<Fun> make_indirect_fun( Fun f )
-    {
-        return indirect_fun<Fun>( f );
-    }
-
-
-    template
-    < 
-        class Fun, 
-        class Arg1, 
-        class Arg2 = Arg1 
-#ifdef BOOST_NO_SFINAE
-      , class Result = bool   
-#endif           
-    >
-    class void_ptr_indirect_fun
-    {
-        Fun fun;
-                
-    public:
-        
-        void_ptr_indirect_fun() : fun(Fun())
-        { }
-
-        void_ptr_indirect_fun( Fun f ) : fun(f)
-        { }
-        
-        template< class Void >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else            
-        typename ptr_container_detail::make_lazy<
-            boost::result_of<const Fun(const Arg1&)>, Void>::type
-#endif            
-        operator()( const Void* r ) const
-        { 
-            BOOST_STATIC_ASSERT(boost::is_void<Void>::value);
-            BOOST_ASSERT( r != 0 );
-            return fun( * static_cast<const Arg1*>( r ) );
-        }
-
-        template< class Void >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else                    
-        typename ptr_container_detail::make_lazy<
-            boost::result_of<const Fun(const Arg1&, const Arg2&)>, Void>::type
-#endif            
-        operator()( const Void* l, const Void* r ) const
-        { 
-            BOOST_STATIC_ASSERT(boost::is_void<Void>::value);
-            BOOST_ASSERT( l != 0 && r != 0 );
-            return fun( * static_cast<const Arg1*>( l ), * static_cast<const Arg2*>( r ) );
-        }
-    };
-
-    template< class Arg, class Fun >
-    inline void_ptr_indirect_fun<Fun,Arg> make_void_ptr_indirect_fun( Fun f )
-    {
-        return void_ptr_indirect_fun<Fun,Arg>( f );
-    }
-     
-} // namespace 'boost'
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/nullable.hpp b/contrib/restricted/boost/boost/ptr_container/nullable.hpp
deleted file mode 100644
index 5934812f48..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/nullable.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-
-#ifndef BOOST_INDIRECT_CONTAINER_NULLABLE_HPP
-#define BOOST_INDIRECT_CONTAINER_NULLABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/config.hpp>
-
-namespace boost
-{
-    
-    template< class T >
-    struct nullable
-    {
-        typedef T type;
-    };   
-
-    namespace ptr_container_detail
-    {
-        template< class T >
-        type_traits::yes_type is_nullable( const nullable<T>* );
-
-        type_traits::no_type is_nullable( ... );        
-    }
-
-    template< class T >
-    struct is_nullable
-    {
-    private:
-            BOOST_STATIC_CONSTANT( T*, var );
-    public:
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(push)  
-#pragma warning(disable:6334)  
-#endif  
-
-            BOOST_STATIC_CONSTANT(bool, value = sizeof( ptr_container_detail::is_nullable( var ) ) 
-                                                == sizeof( type_traits::yes_type ) );
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(pop)  
-#endif  
-            
-    };
-    
-    template< class T >
-    struct remove_nullable
-    {
-        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< is_nullable<T>,
-                                                      T,
-                                            mpl::identity<T> >::type
-            type;
-    };
-
-    namespace ptr_container_detail
-    {
-        template< class T >
-        struct void_ptr
-        {
-            typedef BOOST_DEDUCED_TYPENAME 
-                mpl::if_c< boost::is_const< 
-                              BOOST_DEDUCED_TYPENAME boost::remove_nullable<T>::type >::value,
-                           const void*, void* >::type type;                                                       
-        };
-    }
-}
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_array.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_array.hpp
deleted file mode 100644
index cf9d4d4f01..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_array.hpp
+++ /dev/null
@@ -1,298 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
-#define BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/array.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template
-        <
-            class T,
-            size_t N,
-            class Allocator = int // dummy
-        >
-        class ptr_array_impl : public boost::array<T,N>
-        {
-        public:
-            typedef Allocator allocator_type;
-
-            ptr_array_impl( Allocator /*a*/ = Allocator() )
-            {
-                this->assign( 0 );
-            }
-
-            ptr_array_impl( size_t, T*, Allocator /*a*/ = Allocator() )
-            {
-                this->assign( 0 );
-            }
-        };
-    }
-
-    template
-    <
-        class T,
-        size_t N,
-        class CloneAllocator = heap_clone_allocator
-    >
-    class ptr_array : public
-        ptr_sequence_adapter< T,
-            ptr_container_detail::ptr_array_impl<
-                typename ptr_container_detail::void_ptr<T>::type,N>,
-                              CloneAllocator >
-    {
-    private:
-        typedef ptr_sequence_adapter< T,
-            ptr_container_detail::ptr_array_impl<
-                typename ptr_container_detail::void_ptr<T>::type,N>,
-                                      CloneAllocator >
-            base_class;
-
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type U;
-
-        typedef ptr_array<T,N,CloneAllocator>
-                          this_type;
-
-    public:
-        typedef std::size_t size_type;
-        typedef U*          value_type;
-        typedef U*          pointer;
-        typedef U&          reference;
-        typedef const U&    const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_class::auto_type
-                            auto_type;
-
-    public: // constructors
-        ptr_array() : base_class()
-        { }
-
-        ptr_array( const ptr_array& r )
-        {
-            size_t i = 0;
-            for( ; i != N; ++i )
-                this->base()[i] = this->null_policy_allocate_clone( 
-                                        static_cast<const U*>( &r[i] ) ); 
-        }
-
-        template< class U >
-        ptr_array( const ptr_array<U,N>& r )
-        {
-            size_t i = 0;
-            for( ; i != N; ++i )
-                this->base()[i] = this->null_policy_allocate_clone( 
-                                        static_cast<const T*>( &r[i] ) ); 
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        explicit ptr_array( std::auto_ptr<this_type> r )
-        : base_class( r ) { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        explicit ptr_array( std::unique_ptr<this_type> r )
-        : base_class( std::move( r ) ) { }
-#endif
-
-        ptr_array& operator=( ptr_array r )
-        {
-            this->swap( r );
-            return *this;            
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        ptr_array& operator=( std::auto_ptr<this_type> r )
-        {
-            base_class::operator=(r);
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        ptr_array& operator=( std::unique_ptr<this_type> r )
-        {
-            base_class::operator=(std::move(r));
-            return *this;
-        }
-#endif
-
-#ifndef BOOST_NO_AUTO_PTR
-        std::auto_ptr<this_type> release()
-        {
-            std::auto_ptr<this_type> ptr( new this_type );
-            this->swap( *ptr );
-            return ptr;
-        }
-
-        std::auto_ptr<this_type> clone() const
-        {
-            std::auto_ptr<this_type> pa( new this_type );
-            clone_array_elements( *pa );
-            return pa;
-        }
-#else
-        std::unique_ptr<this_type> release()
-        {
-            std::unique_ptr<this_type> ptr( new this_type );
-            this->swap( *ptr );
-            return ptr;
-        }
-
-        std::unique_ptr<this_type> clone() const
-        {
-            std::unique_ptr<this_type> pa( new this_type );
-            clone_array_elements( *pa );
-            return pa;
-        }
-#endif
-    private:
-        void clone_array_elements( this_type &pa ) const
-        {
-            for( size_t i = 0; i != N; ++i )
-            {
-                if( !this->is_null(i) )
-                    pa.replace( i, pa.null_policy_allocate_clone( &(*this)[i] ) );
-            }
-        }
-
-    private: // hide some members
-        using base_class::insert;
-        using base_class::erase;
-        using base_class::push_back;
-        using base_class::push_front;
-        using base_class::pop_front;
-        using base_class::pop_back;
-        using base_class::transfer;
-        using base_class::get_allocator;
-
-    public: // compile-time interface
-
-        template< size_t idx >
-        auto_type replace( U* r ) // strong
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-
-            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
-            auto_type res( static_cast<U*>(this->base()[idx]), *this ); // nothrow                    
-            this->base()[idx] = r;                                      // nothrow
-            return boost::ptr_container::move(res);                     // nothrow 
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< size_t idx, class V >
-        auto_type replace( std::auto_ptr<V> r )
-        {
-            return replace<idx>( r.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< size_t idx, class V >
-        auto_type replace( std::unique_ptr<V> r )
-        {
-            return replace<idx>( r.release() );
-        }
-#endif
-
-        auto_type replace( size_t idx, U* r ) // strong
-        {
-            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
-
-            auto_type ptr( r, *this );
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= N, bad_index,
-                                                 "'replace()' aout of bounds" );
-
-            auto_type res( static_cast<U*>(this->base()[idx]), *this ); // nothrow
-            this->base()[idx] = ptr.release();                          // nothrow
-            return boost::ptr_container::move(res);                     // nothrow 
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class V >
-        auto_type replace( size_t idx, std::auto_ptr<V> r )
-        {
-            return replace( idx, r.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class V >
-        auto_type replace( size_t idx, std::unique_ptr<V> r )
-        {
-            return replace( idx, r.release() );
-        }
-#endif
-
-        using base_class::at;
-
-        template< size_t idx >
-        T& at()
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return (*this)[idx];
-        }
-
-        template< size_t idx >
-        const T& at() const
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return (*this)[idx];
-        }
-
-        bool is_null( size_t idx ) const
-        {
-            return base_class::is_null(idx);
-        }
-
-        template< size_t idx >
-        bool is_null() const
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return this->base()[idx] == 0;
-        }
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, size_t size, typename CA >
-    inline ptr_array<T,size,CA>* new_clone( const ptr_array<T,size,CA>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, size_t size, typename CA >
-    inline void swap( ptr_array<T,size,CA>& l, ptr_array<T,size,CA>& r )
-    {
-        l.swap(r);
-    }
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_circular_buffer.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_circular_buffer.hpp
deleted file mode 100644
index fa5b78d33a..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_circular_buffer.hpp
+++ /dev/null
@@ -1,579 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
-#define BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/circular_buffer.hpp>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <boost/next_prior.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_circular_buffer : public 
-        ptr_sequence_adapter< T, boost::circular_buffer<
-                typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                              CloneAllocator >
-    {  
-        typedef ptr_sequence_adapter< T, boost::circular_buffer<
-                typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                                      CloneAllocator > 
-            base_type;
-
-        typedef boost::circular_buffer<typename 
-            ptr_container_detail::void_ptr<T>::type,Allocator>  circular_buffer_type;
-        typedef ptr_circular_buffer<T,CloneAllocator,Allocator> this_type;
-        
-    public: // typedefs
-        typedef typename base_type::value_type     value_type;
-        typedef value_type*                        pointer;
-        typedef const value_type*                  const_pointer;
-        typedef typename base_type::size_type      size_type;
-        typedef typename base_type::allocator_type allocator_type;
-        typedef typename base_type::iterator       iterator;
-        typedef typename base_type::const_iterator const_iterator;
-        typedef typename base_type::auto_type      auto_type;
-        
-        typedef std::pair<pointer,size_type>                  array_range;
-        typedef std::pair<const_pointer,size_type>            const_array_range;
-        typedef typename circular_buffer_type::capacity_type  capacity_type;
-
-    public: // constructors
-        ptr_circular_buffer()
-        { }
-
-        explicit ptr_circular_buffer( capacity_type n )
-          : base_type( n, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-        
-        ptr_circular_buffer( capacity_type n,
-                             const allocator_type& alloc )
-          : base_type( n, alloc, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class ForwardIterator >
-        ptr_circular_buffer( ForwardIterator first, ForwardIterator last )
-          : base_type( first, last, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class InputIterator >
-        ptr_circular_buffer( capacity_type n, InputIterator first, InputIterator last )
-          : base_type( n, first, last, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        ptr_circular_buffer( const ptr_circular_buffer& r )
-          : base_type( r.size(), r.begin(), r.end(), 
-                       ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class U >
-        ptr_circular_buffer( const ptr_circular_buffer<U>& r )
-          : base_type( r.size(), r.begin(), r.end(), 
-                       ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        ptr_circular_buffer& operator=( ptr_circular_buffer r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_circular_buffer,
-                                                      base_type, this_type )
-            
-    public: // allocators
-        allocator_type& get_allocator() 
-        {
-            return this->base().get_allocator();
-        }
-
-        allocator_type get_allocator() const
-        {
-            return this->base().get_allocator();
-        }
-
-    public: // circular buffer functions
-        array_range array_one() // nothrow
-        {
-            typename circular_buffer_type::array_range r = this->base().array_one();
-            return array_range( reinterpret_cast<pointer>(r.first), r.second );
-        }
-
-        const_array_range array_one() const // nothrow
-        {
-            typename circular_buffer_type::const_array_range r = this->base().array_one();
-            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
-        }
-
-        array_range array_two() // nothrow
-        {
-            typename circular_buffer_type::array_range r = this->base().array_two();
-            return array_range( reinterpret_cast<pointer>(r.first), r.second );
-        }
-
-        const_array_range array_two() const // nothrow
-        {
-            typename circular_buffer_type::const_array_range r = this->base().array_two();
-            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
-        }
-
-        pointer linearize() // nothrow
-        {
-            return reinterpret_cast<pointer>(this->base().linearize());
-        }
-
-        bool full() const // nothrow
-        {
-            return this->base().full();
-        }
-
-        size_type reserve() const // nothrow
-        {
-            return this->base().reserve();
-        }
-
-        void reserve( size_type n ) // strong
-        {
-            if( capacity() < n )
-                set_capacity( n );
-        }
-
-        capacity_type capacity() const // nothrow
-        {
-            return this->base().capacity();
-        }
-
-        void set_capacity( capacity_type new_capacity ) // strong
-        {
-            if( this->size() > new_capacity )
-            {
-                this->erase( this->begin() + new_capacity, this->end() );
-            }
-            this->base().set_capacity( new_capacity );
-        }
-
-        void rset_capacity( capacity_type new_capacity ) // strong
-        {
-            if( this->size() > new_capacity )
-            {
-                this->erase( this->begin(), 
-                             this->begin() + (this->size()-new_capacity) );
-            }
-            this->base().rset_capacity( new_capacity );
-        }
-
-        void resize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( new BOOST_DEDUCED_TYPENAME 
-                                     boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void resize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );        
-        }
-
-        void rresize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( new BOOST_DEDUCED_TYPENAME 
-                                      boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void rresize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }           
-
-        template< class InputIterator >
-        void assign( InputIterator first, InputIterator last ) // strong
-        { 
-            ptr_circular_buffer temp( first, last );
-            this->swap( temp );
-        }
-
-        template< class Range >
-        void assign( const Range& r ) // strong
-        {
-            assign( boost::begin(r), boost::end(r ) );
-        }
-
-        void assign( size_type n, value_type to_clone ) // strong
-        {
-            ptr_circular_buffer temp( n );
-            for( size_type i = 0u; i != n; ++i )
-               temp.push_back( temp.null_policy_allocate_clone( to_clone ) );
-            this->swap( temp ); 
-        }
-        
-        void assign( capacity_type capacity, size_type n, 
-                     value_type to_clone ) // basic
-        {
-            this->assign( (std::min)(n,capacity), to_clone );
-        }
-
-        template< class InputIterator >
-        void assign( capacity_type capacity, 
-                     InputIterator first, InputIterator last ) // basic
-        {
-            this->assign( first, last );
-            this->set_capacity( capacity );
-        }
-
-        void push_back( value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'push_back()'" );
-         
-            auto_type old_ptr( value_type(), *this );
-            if( full() )
-                old_ptr.reset( &*this->begin(), *this );
-            this->base().push_back( ptr );           
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        void push_back( std::auto_ptr<U> ptr ) // nothrow
-        {
-            push_back( ptr.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        void push_back( std::unique_ptr<U> ptr ) // nothrow
-        {
-            push_back( ptr.release() );
-        }
-#endif
-
-        void push_front( value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'push_front()'" );
-
-            auto_type old_ptr( value_type(), *this );
-            if( full() )
-                old_ptr.reset( &*(--this->end()), *this );
-            this->base().push_front( ptr );            
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        void push_front( std::auto_ptr<U> ptr ) // nothrow
-        {
-            push_front( ptr.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        void push_front( std::unique_ptr<U> ptr ) // nothrow
-        {
-            push_front( ptr.release() );
-        }
-#endif
-
-        iterator insert( iterator pos, value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'insert()'" );
-
-            auto_type new_ptr( ptr, *this );
-            iterator b = this->begin();
-            if( full() && pos == b )
-                return b;
-            
-            new_ptr.release();            
-            auto_type old_ptr( value_type(), *this );
-            if( full() )
-                old_ptr.reset( &*this->begin(), *this );
-
-            return this->base().insert( pos.base(), ptr );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
-        {
-            return insert( pos, ptr.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator pos, std::unique_ptr<U> ptr ) // nothrow
-        {
-            return insert( pos, ptr.release() );
-        }
-#endif
-
-        template< class InputIterator >
-        void insert( iterator pos, InputIterator first, InputIterator last ) // basic
-        {
-            for( ; first != last; ++first, ++pos )
-                pos = insert( pos, this->null_policy_allocate_clone( &*first ) );                
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( iterator before, const Range& r )
-        {
-            insert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-           
-        iterator rinsert( iterator pos, value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'rinsert()'" );
-
-            auto_type new_ptr( ptr, *this );
-            iterator b = this->end();
-            if (full() && pos == b)
-                return b;
-                       
-            new_ptr.release();            
-            auto_type old_ptr( value_type(), *this );
-            if( full() )
-                old_ptr.reset( &this->back(), *this );
-
-            return this->base().rinsert( pos.base(), ptr );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator rinsert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
-        {
-            return rinsert( pos, ptr.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator rinsert( iterator pos, std::unique_ptr<U> ptr ) // nothrow
-        {
-            return rinsert( pos, ptr.release() );
-        }
-#endif
-
- 
-        template< class InputIterator >
-        void rinsert( iterator pos, InputIterator first, InputIterator last ) // basic
-        {
-            for( ; first != last; ++first, ++pos )
-                pos = rinsert( pos, this->null_policy_allocate_clone( &*first ) );                
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        rinsert( iterator before, const Range& r )
-        {
-            rinsert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-        iterator rerase( iterator pos ) // nothrow
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( pos != this->end() );
-
-            this->remove( pos );
-            return iterator( this->base().rerase( pos.base() ) );
-        }
-
-        iterator rerase( iterator first, iterator last ) // nothrow
-        {
-            this->remove( first, last );
-            return iterator( this->base().rerase( first.base(),
-                                                  last.base() ) );
-        }
-
-        template< class Range >
-        iterator rerase( const Range& r ) // nothrow
-        {
-            return rerase( boost::begin(r), boost::end(r) );
-        }
-
-        void rotate( const_iterator new_begin ) // nothrow
-        {
-            this->base().rotate( new_begin.base() );
-        }
-
-    public: // transfer        
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, 
-                       PtrSeqAdapter& from ) // nothrow
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            for( BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator begin = first; 
-                 begin != last;  ++begin, ++before )
-                before = insert( before, &*begin );          // nothrow
-            from.base().erase( first.base(), last.base() );  // nothrow
-        }
-
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, 
-                       PtrSeqAdapter& from ) // nothrow
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            insert( before, &*object );          // nothrow 
-            from.base().erase( object.base() );  // nothrow 
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        
-        template< class PtrSeqAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                      BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type
-        transfer( iterator before, const Range& r, PtrSeqAdapter& from ) // nothrow
-        {
-            transfer( before, boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, PtrSeqAdapter& from ) // nothrow
-        {
-            transfer( before, from.begin(), from.end(), from );            
-        }
-
-    public: // C-array support
-    
-        void transfer( iterator before, value_type* from, 
-                       size_type size, bool delete_from = true ) // nothrow 
-        {
-            BOOST_ASSERT( from != 0 );
-            if( delete_from )
-            {
-                BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
-                    deleter( *this, from, size );                  // nothrow
-                for( size_type i = 0u; i != size; ++i, ++before )
-                    before = insert( before, *(from+i) );          // nothrow
-                deleter.release();                                 // nothrow
-            }
-            else
-            {
-                for( size_type i = 0u; i != size; ++i, ++before )
-                    before = insert( before, *(from+i) );          // nothrow
-           }
-        }
-
-        value_type* c_array() // nothrow
-        {
-            if( this->empty() )
-                return 0;
-            this->linearize();
-            T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
-            return res;
-        }
-
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_circular_buffer<T,CA,A>* new_clone( const ptr_circular_buffer<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_circular_buffer<T,CA,A>& l, ptr_circular_buffer<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-    
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_container.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_container.hpp
deleted file mode 100644
index 6b1c92d515..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_container.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
- 
-#ifndef BOOST_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/ptr_array.hpp>
-#include <boost/ptr_container/ptr_deque.hpp>
-#include <boost/ptr_container/ptr_list.hpp>
-#include <boost/ptr_container/ptr_map.hpp>
-#include <boost/ptr_container/ptr_set.hpp>
-#include <boost/ptr_container/ptr_vector.hpp>
-#include <boost/ptr_container/ptr_unordered_map.hpp>
-#include <boost/ptr_container/ptr_unordered_set.hpp>
-#include <boost/ptr_container/ptr_circular_buffer.hpp>
-#include <boost/ptr_container/ptr_inserter.hpp>
-
-#endif
-
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_deque.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_deque.hpp
deleted file mode 100644
index 2278183271..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_deque.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_DEQUE_HPP
-#define BOOST_PTR_CONTAINER_PTR_DEQUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <deque>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-    
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<typename ptr_container_detail::void_ptr<T>::type>
-    >
-    class ptr_deque : public 
-        ptr_sequence_adapter< T, std::deque<
-            typename ptr_container_detail::void_ptr<T>::type,Allocator>,
-                              CloneAllocator >
-    {
-         typedef   ptr_sequence_adapter< T, std::deque<
-             typename ptr_container_detail::void_ptr<T>::type,Allocator>,     
-                                         CloneAllocator >
-          base_class;
-
-         typedef ptr_deque<T,CloneAllocator,Allocator> this_type; 
-         
-    public:
-
-      BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_deque,
-                                                    base_class,
-                                                    this_type )
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-    
-    template< typename T, typename CA, typename A >
-    inline ptr_deque<T,CA,A>* new_clone( const ptr_deque<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_deque<T,CA,A>& l, ptr_deque<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_inserter.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_inserter.hpp
deleted file mode 100644
index 770f5254ba..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_inserter.hpp
+++ /dev/null
@@ -1,306 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-    #pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <iterator>
-#include <memory>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-namespace ptr_container
-{
-    template< class PtrContainer >
-    class ptr_back_insert_iterator;
-
-    template< class PtrContainer >
-    class ptr_front_insert_iterator;
-    
-    template< class PtrContainer >
-    class ptr_insert_iterator;
-
-    template< class PtrContainer >
-    ptr_back_insert_iterator<PtrContainer> 
-    ptr_back_inserter( PtrContainer& cont );
-
-    template< class PtrContainer >
-    ptr_front_insert_iterator<PtrContainer> 
-    ptr_front_inserter( PtrContainer& cont );
-
-    template< class PtrContainer >
-    ptr_insert_iterator<PtrContainer> 
-    ptr_inserter( PtrContainer& cont, typename PtrContainer::iterator before );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Implementation
-    ////////////////////////////////////////////////////////////////////////// 
-
-
-    template< class PtrContainer >
-    class ptr_back_insert_iterator
-    {
-    public:
-        typedef std::output_iterator_tag iterator_category;
-        typedef void value_type;
-        typedef void difference_type;
-        typedef void pointer;
-        typedef void reference;
-        typedef PtrContainer container_type;
-
-    public:
-        explicit ptr_back_insert_iterator( PtrContainer& cont )
-        : container(&cont)
-        { }
-
-        ptr_back_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj 
-                          = container->null_policy_allocate_clone(r);
-            container->push_back( obj );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class T >
-        ptr_back_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            container->push_back( r );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class T >
-        ptr_back_insert_iterator& 
-        operator=( std::unique_ptr<T> r )
-        {
-            container->push_back( std::move( r ) );
-            return *this;
-        }
-#endif
-
-        ptr_back_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            container->push_back( container->null_policy_allocate_clone(&r) );
-            return *this;
-        }
-
-        ptr_back_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_back_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_back_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer* container;
-    };
-
-
-    
-    template< class PtrContainer >
-    class ptr_front_insert_iterator
-    {
-    public:
-        typedef std::output_iterator_tag iterator_category;
-        typedef void value_type;
-        typedef void difference_type;
-        typedef void pointer;
-        typedef void reference;
-        typedef PtrContainer container_type;
-
-    public:
-        explicit ptr_front_insert_iterator( PtrContainer& cont )
-        : container(&cont)
-        { }
-
-        ptr_front_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj 
-                              = container->null_policy_allocate_clone(r);
-            container->push_front( obj );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class T >
-        ptr_front_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            container->push_front( r );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class T >
-        ptr_front_insert_iterator& 
-        operator=( std::unique_ptr<T> r )
-        {
-            container->push_front( std::move( r ) );
-            return *this;
-        }
-#endif
-        
-        ptr_front_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            container->push_front( container->null_policy_allocate_clone(&r) );
-            return *this;
-        }
-
-        ptr_front_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_front_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_front_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer* container;
-    };
-
-
-    
-    template< class PtrContainer >
-    class ptr_insert_iterator
-    {
-    public:
-        typedef std::output_iterator_tag iterator_category;
-        typedef void value_type;
-        typedef void difference_type;
-        typedef void pointer;
-        typedef void reference;
-        typedef PtrContainer container_type;
-
-    public:
-        ptr_insert_iterator( PtrContainer& cont,
-                               typename PtrContainer::iterator before )
-        : container(&cont), iter(before)
-        { }
-
-        ptr_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj = 
-                        container->null_policy_allocate_clone(r);
-
-            iter = container->insert( iter, obj );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class T >
-        ptr_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            iter = container->insert( iter, r );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class T >
-        ptr_insert_iterator& 
-        operator=( std::unique_ptr<T> r )
-        {
-            iter = container->insert( iter, std::move( r ) );
-            return *this;
-        }
-#endif
-        
-        ptr_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            iter = container->insert( iter, 
-                              container->null_policy_allocate_clone(&r) );
-            return *this;
-        }
-
-        ptr_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer*                    container;
-        typename PtrContainer::iterator  iter;
-    };
-
-    template< class PtrContainer >
-    inline ptr_back_insert_iterator<PtrContainer> 
-    ptr_back_inserter( PtrContainer& cont )
-    {
-        return ptr_back_insert_iterator<PtrContainer>( cont );
-    }
-
-    template< class PtrContainer >
-    inline ptr_front_insert_iterator<PtrContainer> 
-    ptr_front_inserter( PtrContainer& cont )
-    {
-        return ptr_front_insert_iterator<PtrContainer>( cont );
-    }
-
-    template< class PtrContainer >
-    inline ptr_insert_iterator<PtrContainer> 
-    ptr_inserter( PtrContainer& cont, 
-                    typename PtrContainer::iterator before )
-    {
-        return ptr_insert_iterator<PtrContainer>( cont, before );
-    }
-    
-} // namespace 'ptr_container'
-} // namespace 'boost'
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_list.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_list.hpp
deleted file mode 100644
index b170f0e7f2..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_list.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_LIST_HPP
-#define BOOST_PTR_CONTAINER_PTR_LIST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <list>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<typename ptr_container_detail::void_ptr<T>::type>
-    >
-    class ptr_list : public 
-        ptr_sequence_adapter< T, std::list<
-            typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                              CloneAllocator >
-    {
-        typedef    ptr_sequence_adapter< T, std::list<
-            typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                                         CloneAllocator >
-            base_class;
-
-        typedef ptr_list<T,CloneAllocator,Allocator>  this_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::remove_nullable<T>::type U;
-        
-    public:
-        BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_list, 
-                                                      base_class,
-                                                      this_type )
-
-        typedef BOOST_DEDUCED_TYPENAME base_class::value_type value_type;
-        
-    public:
-        using base_class::merge;
-        
-        void merge( ptr_list& x )                                 
-        {
-            merge( x, std::less<U>() );
-        }
-
-        template< typename Compare > 
-        void merge( ptr_list& x, Compare comp )                   
-        {
-            this->base().merge( x.base(), void_ptr_indirect_fun<Compare,U>( comp ) ); }
-
-        void sort()                                                    
-        { 
-            sort( std::less<U>() ); 
-        };
-
-        template< typename Compare > 
-        void sort( Compare comp )                             
-        {
-            this->base().sort( void_ptr_indirect_fun<Compare,U>( comp ) );
-        }
-
-        template< class Pred >
-        void erase_if( iterator first, iterator last, Pred pred )
-        {
-            base_class::erase_if( first, last, pred );
-        }
-        
-        template< class Pred >
-        void erase_if( Pred pred )
-        {
-            this->base().remove_if( BOOST_DEDUCED_TYPENAME base_class:: 
-                    BOOST_NESTED_TEMPLATE void_ptr_delete_if<Pred,value_type>
-                                    (pred) );
-        } 
-
-    }; // class 'ptr_list'
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_list<T,CA,A>* new_clone( const ptr_list<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_list<T,CA,A>& l, ptr_list<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_map.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_map.hpp
deleted file mode 100644
index 6e43c47625..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_map.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_PTR_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <map>
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-    
-    template
-    < 
-        class Key, 
-        class T, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,typename ptr_container_detail::void_ptr<T>::type> >
-    >
-    class ptr_map : 
-        public ptr_map_adapter<T,std::map<Key,
-            typename ptr_container_detail::void_ptr<T>::type,
-                               Compare,Allocator>,CloneAllocator>
-    {
-        typedef ptr_map_adapter<T,std::map<Key,
-            typename ptr_container_detail::void_ptr<T>::type,
-                                Compare,Allocator>,CloneAllocator>
-            base_type;
-
-        typedef ptr_map<Key,T,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_map()
-        { }
-        
-        explicit ptr_map( const Compare& comp,
-                          const Allocator& a  = Allocator() ) 
-          : base_type( comp, a ) { }
-
-        template< class InputIterator >
-        ptr_map( InputIterator first, InputIterator last )
-          : base_type( first, last )
-        { }
-        
-        template< class InputIterator >
-        ptr_map( InputIterator first, InputIterator last, 
-                 const Compare& comp,
-                 const Allocator& a  = Allocator() )
-          : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_map, base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_map( const ptr_map<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_map& operator=( ptr_map r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-
-
-    template
-    < 
-        class Key, 
-        class T, 
-        class Compare        = std::less<Key>, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_multimap : 
-        public ptr_multimap_adapter<T,std::multimap<Key,void*,
-                                    Compare,Allocator>,CloneAllocator>
-    {
-        typedef ptr_multimap_adapter<T,std::multimap<Key,void*,
-                                     Compare,Allocator>,CloneAllocator>
-             base_type;
-
-        typedef ptr_multimap<Key,T,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_multimap()
-        { }
-        
-        explicit ptr_multimap( const Compare& comp,
-                               const Allocator& a  = Allocator() ) 
-          : base_type( comp, a ) { }
-
-        template< class InputIterator >
-        ptr_multimap( InputIterator first, InputIterator last )
-          : base_type( first,  last )
-        { }
-        
-        template< class InputIterator >
-        ptr_multimap( InputIterator first, InputIterator last,
-                      const Compare& comp,
-                      const Allocator& a  = Allocator() )
-          : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multimap, 
-                                                      base_type,
-                                                      this_type )
-
-        template< class U >
-        ptr_multimap( const ptr_multimap<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_multimap& operator=( ptr_multimap r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< class K, class T, class C, class CA, class A >
-    inline ptr_map<K,T,C,CA,A>* new_clone( const ptr_map<K,T,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< class K, class T, class C, class CA, class A >
-    inline ptr_multimap<K,T,C,CA,A>* new_clone( const ptr_multimap<K,T,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename T, typename C, typename CA, typename A >
-    inline void swap( ptr_map<K,T,C,CA,A>& l, ptr_map<K,T,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename T, typename C, typename CA, typename A >
-    inline void swap( ptr_multimap<K,T,C,CA,A>& l, ptr_multimap<K,T,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_map_adapter.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_map_adapter.hpp
deleted file mode 100644
index 04caf8706a..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_map_adapter.hpp
+++ /dev/null
@@ -1,982 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/map_iterator.hpp>
-#include <boost/ptr_container/detail/associative_ptr_container.hpp>
-#include <boost/ptr_container/detail/meta_functions.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/range/iterator_range.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-
-    template
-    < 
-        class T,
-        class VoidPtrMap,
-        bool  Ordered
-    >
-    struct map_config
-    {
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type
-                     U;
-        typedef VoidPtrMap 
-                     void_container_type;
-        
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type
-                     allocator_type;
-        
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_value_compare<VoidPtrMap>, 
-                          mpl::identity<void> >::type
-                    value_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_key_compare<VoidPtrMap>, 
-                          mpl::identity<void> >::type
-                    key_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_hasher<VoidPtrMap> >::type
-                    hasher;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_key_equal<VoidPtrMap> >::type
-                    key_equal;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::if_c<Ordered,
-                     ptr_container_detail::ordered_associative_container_tag,
-                     ptr_container_detail::unordered_associative_container_tag>::type
-                    container_type;
-        
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::key_type
-                     key_type;
-        
-        typedef U    value_type;
-
-        typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::iterator, key_type, U* const >
-                     iterator;
-        
-        typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::const_iterator, key_type, const U* const>
-                     const_iterator;
-        
-        typedef ptr_map_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrMap>,
-                            select_local_iterator<VoidPtrMap> >::type,
-             key_type, U* const >
-                    local_iterator;
-
-       typedef ptr_map_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrMap>,
-                            select_const_local_iterator<VoidPtrMap> >::type,
-             key_type, const U* const >
-                    const_local_iterator;  
-       
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return i->second;
-        }
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return i->second;
-        }
-
-        BOOST_STATIC_CONSTANT( bool, allow_null = boost::is_nullable<T>::value );
-    };
-    
-    
-
-    template
-    < 
-        class T,
-        class VoidPtrMap, 
-        class CloneAllocator,
-        bool  Ordered
-    >
-    class ptr_map_adapter_base : 
-        public ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>,
-                                                    CloneAllocator >
-    {
-        typedef ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>,
-                                                     CloneAllocator > 
-            base_type;
-
-        typedef map_config<T,VoidPtrMap,Ordered>                           config;
-        typedef ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered>  this_type;
-        
-    public:
-
-        typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type
-                    allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator
-                    iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                    const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                    size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::value_type 
-                    mapped_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference
-                    mapped_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_mapped_reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_value<iterator>::type
-                    value_type;
-        typedef value_type
-                    reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_value<const_iterator>::type
-                    const_reference;
-        typedef value_type 
-                    pointer;
-        typedef const_reference 
-                    const_pointer;
-
-    private:
-        const_mapped_reference lookup( const key_type& key ) const
-        {
-           const_iterator i = this->find( key );
-           BOOST_PTR_CONTAINER_THROW_EXCEPTION( i == this->end(), bad_ptr_container_operation,
-                                                "'ptr_map/multimap::at()' could"
-                                                " not find key" );
-           return *i->second;
-        }
-
-        struct eraser // scope guard
-        {
-            bool            released_;
-            VoidPtrMap*     m_;
-            const key_type& key_;
-
-            eraser( VoidPtrMap* m, const key_type& key ) 
-              : released_(false), m_(m), key_(key)
-            {}
-
-            ~eraser() 
-            {
-                if( !released_ )
-                    m_->erase(key_);
-            }
-
-            void release() { released_ = true; }
-
-        private:  
-            eraser& operator=(const eraser&);  
-        };
-
-        mapped_reference insert_lookup( const key_type& key )
-        {
-            void*& ref = this->base()[key];
-            if( ref )
-            {
-                return *static_cast<mapped_type>(ref);
-            }
-            else
-            {
-                eraser e(&this->base(),key);      // nothrow
-                mapped_type res = new T();        // strong 
-                ref = res;                        // nothrow
-                e.release();                      // nothrow
-                return *res;
-            }
-          }
-        
-    public:
-
-        ptr_map_adapter_base()
-        { }
-
-        template< class SizeType >
-        explicit ptr_map_adapter_base( SizeType n, 
-                                       ptr_container_detail::unordered_associative_container_tag tag )
-        : base_type( n, tag )
-        { }
-
-        template< class Compare, class Allocator >
-        ptr_map_adapter_base( const Compare& comp,
-                              const Allocator& a ) 
-        : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_map_adapter_base( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-                
-        template< class InputIterator >
-        ptr_map_adapter_base( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-                
-        template< class InputIterator, class Comp >
-        ptr_map_adapter_base( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a = allocator_type() )
-        : base_type( first, last, comp, a )
-        { }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_map_adapter_base( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-                
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit ptr_map_adapter_base( std::auto_ptr<PtrContainer> clone )
-        : base_type( clone )
-        { }
-
-        template< typename PtrContainer >
-        ptr_map_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( clone );
-            return *this;
-        }        
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit ptr_map_adapter_base( std::unique_ptr<PtrContainer> clone )
-        : base_type( std::move( clone ) )
-        { }
-
-        template< typename PtrContainer >
-        ptr_map_adapter_base& operator=( std::unique_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( std::move( clone ) );
-            return *this;
-        }
-#endif
-
-        iterator find( const key_type& x )                                                
-        {                                                                            
-            return iterator( this->base().find( x ) );                                
-        }                                                                            
-
-        const_iterator find( const key_type& x ) const                                    
-        {                                                                            
-            return const_iterator( this->base().find( x ) );                          
-        }                                                                            
-
-        size_type count( const key_type& x ) const                                        
-        {                                                                            
-            return this->base().count( x );                                           
-        }                                                                            
-                                                                                     
-        iterator lower_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().lower_bound( x ) );                         
-        }                                                                            
-                                                                                     
-        const_iterator lower_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().lower_bound( x ) );                   
-        }                                                                            
-                                                                                     
-        iterator upper_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().upper_bound( x ) );                         
-        }                                                                            
-                                                                                     
-        const_iterator upper_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().upper_bound( x ) );                   
-        }                                                                            
-                                                                                     
-        iterator_range<iterator> equal_range( const key_type& x )                    
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_iterator>
-                 p = this->base().equal_range( x );   
-            return make_iterator_range( iterator( p.first ), iterator( p.second ) );      
-        }                                                                            
-                                                                                     
-        iterator_range<const_iterator> equal_range( const key_type& x ) const  
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 
-                p = this->base().equal_range( x ); 
-            return make_iterator_range( const_iterator( p.first ), 
-                                        const_iterator( p.second ) );    
-        }                                                                            
-                                                                                     
-        mapped_reference at( const key_type& key )  
-        {   
-            return const_cast<mapped_reference>( lookup( key ) ); 
-        }
-                                                                                     
-        const_mapped_reference at( const key_type& key ) const
-        {                                                                            
-            return lookup( key );
-        }
-
-        mapped_reference operator[]( const key_type& key )
-        {
-            return insert_lookup( key );
-        }              
-
-        auto_type replace( iterator where, mapped_type x ) // strong  
-        { 
-            BOOST_ASSERT( where != this->end() );
-            this->enforce_null_policy( x, "Null pointer in 'replace()'" );
-
-            auto_type ptr( x, *this );
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( this->empty(),
-                                                 bad_ptr_container_operation,
-                                                 "'replace()' on empty container" );
-
-            auto_type old( where->second, *this ); // nothrow
-            where.base()->second = ptr.release();  // nothrow, commit
-            return boost::ptr_container::move( old );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        auto_type replace( iterator where, std::auto_ptr<U> x )
-        {
-            return replace( where, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        auto_type replace( iterator where, std::unique_ptr<U> x )
-        {
-            return replace( where, x.release() );
-        }
-#endif
-
-    protected:
-        size_type bucket( const key_type& key ) const
-        {
-            return this->base().bucket( key );
-        }
-    };
-    
-} // ptr_container_detail
-
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_map_adapter
-    /////////////////////////////////////////////////////////////////////////
-    
-    template
-    < 
-        class T,
-        class VoidPtrMap, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_map_adapter : 
-        public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered> 
-            base_type;
-    
-    public:    
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator 
-                     iterator;       
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                     const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                    size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type 
-                    allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type
-                    mapped_type;
-    private:
-
-        void safe_insert( const key_type& key, auto_type ptr ) // strong
-        {
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                res = 
-                this->base().insert( std::make_pair( key, ptr.get() ) ); // strong, commit      
-            if( res.second )                                             // nothrow     
-                ptr.release();                                           // nothrow
-        }
-
-        template< class II >                                               
-        void map_basic_clone_and_insert( II first, II last )                  
-        {       
-            while( first != last )                                            
-            {                                            
-                if( this->find( first->first ) == this->end() )
-                {
-                    const_reference p = *first.base();     // nothrow                    
-                    auto_type ptr( this->null_policy_allocate_clone(p.second), *this ); 
-                                                           // strong 
-                    this->safe_insert( p.first, 
-                                       boost::ptr_container::move( ptr ) );
-                                                           // strong, commit 
-                }
-                ++first;                                                      
-            }                                                                 
-        }
-    
-    public:
-        ptr_map_adapter( )
-        { }
-
-        template< class Comp >
-        explicit ptr_map_adapter( const Comp& comp,
-                                  const allocator_type& a ) 
-          : base_type( comp, a ) { }
-
-        template< class SizeType >
-        explicit ptr_map_adapter( SizeType n,
-            ptr_container_detail::unordered_associative_container_tag tag ) 
-          : base_type( n, tag ) { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_map_adapter( const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-                
-        template< class InputIterator >
-        ptr_map_adapter( InputIterator first, InputIterator last )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-               
-        template< class InputIterator, class Comp >
-        ptr_map_adapter( InputIterator first, InputIterator last, 
-                         const Comp& comp,
-                         const allocator_type& a = allocator_type() )
-          : base_type( comp, a ) 
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_map_adapter( InputIterator first, InputIterator last,
-                         const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-          : base_type( hash, pred, a )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-                
-        ptr_map_adapter( const ptr_map_adapter& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class Key, class U, class CA, bool b >
-        ptr_map_adapter( const ptr_map_adapter<Key,U,CA,b>& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        ptr_map_adapter( std::auto_ptr<U> r ) : base_type( r )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        ptr_map_adapter( std::unique_ptr<U> r ) : base_type( std::move( r ) )
-        { }
-#endif
-
-        ptr_map_adapter& operator=( ptr_map_adapter r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        ptr_map_adapter& operator=( std::auto_ptr<U> r )
-        {
-            base_type::operator=( r );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        ptr_map_adapter& operator=( std::unique_ptr<U> r )
-        {
-            base_type::operator=( std::move( r ) );
-            return *this;
-        }
-#endif
-
-        using base_type::release;
-
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class Range >
-        void insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-    private:
-        std::pair<iterator,bool> insert_impl( const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, "Null pointer in ptr_map_adapter::insert()" );
-
-            auto_type ptr( x, *this );                                  // nothrow
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                 res = this->base().insert( std::make_pair( key, x ) ); // strong, commit      
-            if( res.second )                                            // nothrow     
-                ptr.release();                                          // nothrow
-            return std::make_pair( iterator( res.first ), res.second ); // nothrow        
-        }
-
-        iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_map_adapter::insert()'" );
-            
-            auto_type ptr( x, *this );  // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( before.base(), std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );                       
-        }
-        
-    public:
-        
-        std::pair<iterator,bool> insert( key_type& key, mapped_type x )
-        {
-            return insert_impl( key, x );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        std::pair<iterator,bool> insert( const key_type& key, std::auto_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        std::pair<iterator,bool> insert( const key_type& key, std::unique_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-#endif
-
-        template< class F, class S >
-        iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
-        {
-            this->enforce_null_policy( p.second, 
-                  "Null pointer in 'ptr_map_adapter::insert()'" );
- 
-            auto_type ptr( this->null_policy_allocate_clone(p.second), *this ); 
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                result = this->base().insert( before.base(), 
-                                     std::make_pair(p.first,ptr.get()) ); // strong
-            if( ptr.get() == result->second )
-                ptr.release();
-    
-            return iterator( result );
-        }
-
-        iterator insert( iterator before, key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( before, key, x );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::unique_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-#endif
-        
-        template< class PtrMapAdapter >
-        bool transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 
-                       PtrMapAdapter& from ) // strong
-        {
-            return this->single_transfer( object, from );
-        }
-
-        template< class PtrMapAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, 
-                            PtrMapAdapter& from ) // basic
-        {
-            return this->single_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template< class PtrMapAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrMapAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-        
-#endif
-
-        template< class PtrMapAdapter >
-        size_type transfer( PtrMapAdapter& from ) // basic
-        {
-            return transfer( from.begin(), from.end(), from );
-        }
-  };
-  
-  /////////////////////////////////////////////////////////////////////////
-  // ptr_multimap_adapter
-  /////////////////////////////////////////////////////////////////////////
-
-    template
-    < 
-        class T,
-        class VoidPtrMultiMap, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_multimap_adapter : 
-        public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered>
-             base_type;
-
-    public: // typedefs
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator           
-                       iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator     
-                       const_iterator;           
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                       size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                       key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                       const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type
-                    mapped_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;            
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiMap::allocator_type 
-                    allocator_type;
-    private:
-
-        void safe_insert( const key_type& key, auto_type ptr ) // strong
-        {
-            this->base().insert( 
-                           std::make_pair( key, ptr.get() ) ); // strong, commit      
-            ptr.release();                                     // nothrow
-        }
-        
-        template< typename II >                                               
-        void map_basic_clone_and_insert( II first, II last )                  
-        {                                                         
-            while( first != last )                                            
-            {                                            
-                const_reference pair = *first.base();     // nothrow                     
-                auto_type ptr( this->null_policy_allocate_clone(pair.second), *this );    
-                                                          // strong
-                safe_insert( pair.first, 
-                             boost::ptr_container::move( ptr ) );
-                                                          // strong, commit 
-                ++first;                                                      
-            }                                                                 
-        }
-        
-    public:
-
-        ptr_multimap_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_multimap_adapter( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Comp >
-        explicit ptr_multimap_adapter( const Comp& comp,
-                                       const allocator_type& a )
-          : base_type( comp, a ) { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_multimap_adapter( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_multimap_adapter( InputIterator first, InputIterator last )
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-        
-        template< class InputIterator, class Comp >
-        ptr_multimap_adapter( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a )
-          : base_type( comp, a )
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_multimap_adapter( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-
-        ptr_multimap_adapter( const ptr_multimap_adapter& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class Key, class U, class CA, bool b >
-        ptr_multimap_adapter( const ptr_multimap_adapter<Key,U,CA,b>& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        explicit ptr_multimap_adapter( std::auto_ptr<U> r ) : base_type( r )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        explicit ptr_multimap_adapter( std::unique_ptr<U> r ) : base_type( std::move( r ) )
-        { }
-#endif
-
-        ptr_multimap_adapter& operator=( ptr_multimap_adapter r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        ptr_multimap_adapter& operator=( std::auto_ptr<U> r )
-        {  
-            base_type::operator=( r );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        ptr_multimap_adapter& operator=( std::unique_ptr<U> r )
-        {  
-            base_type::operator=( std::move( r ) );
-            return *this;
-        }
-#endif
-
-        using base_type::release;
-
-    private:
-        iterator insert_impl( const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-
-            auto_type ptr( x, *this );  // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );           
-        }
-
-        iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-            
-            auto_type ptr( x, *this );  // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( before.base(), 
-                                           std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );                       
-        }
-
-    public:
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class Range >
-        void insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-        iterator insert( key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( key, x );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( const key_type& key, std::auto_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( const key_type& key, std::unique_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-#endif
-
-        template< class F, class S >
-        iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
-        {
-            this->enforce_null_policy( p.second, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-            iterator res = insert_impl( before, p.first, 
-                                        this->null_policy_allocate_clone( p.second ) );
-            return res;
-        }
-
-        iterator insert( iterator before, key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( before, key, x );
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::unique_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-#endif
-        
-        template< class PtrMapAdapter >
-        void transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 
-                       PtrMapAdapter& from ) // strong
-        {
-            this->multi_transfer( object, from );
-        }
-
-        template< class PtrMapAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, 
-                            PtrMapAdapter& from ) // basic
-        {
-            return this->multi_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template<  class PtrMapAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrMapAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif        
-        template< class PtrMapAdapter >
-        void transfer( PtrMapAdapter& from ) // basic
-        {
-            transfer( from.begin(), from.end(), from );
-            BOOST_ASSERT( from.empty() );
-        }
-
-    };
-
-    template< class I, class F, class S >
-    inline bool is_null( const ptr_map_iterator<I,F,S>& i )
-    {
-        return i->second == 0;
-    }
-    
-} // namespace 'boost'  
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_sequence_adapter.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_sequence_adapter.hpp
deleted file mode 100644
index 772815268f..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_sequence_adapter.hpp
+++ /dev/null
@@ -1,823 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SEQUENCE_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_SEQUENCE_ADAPTER_HPP
-
-#if defined(__GNUC__)
-    #pragma GCC system_header
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/next_prior.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{   
-namespace ptr_container_detail
-{    
-    template
-    < 
-        class T, 
-        class VoidPtrSeq
-    >
-    struct sequence_config
-    {
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type
-                    U;
-        typedef VoidPtrSeq
-                    void_container_type;
-
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrSeq::allocator_type
-                    allocator_type;
-        
-        typedef U   value_type;
-
-        typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U > 
-                    iterator;
-       
-        typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U >
-                    const_iterator;
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return static_cast<U*>( *i.base() );
-        }
-        
-#else
-        template< class Iter >
-        static U* get_pointer( void_ptr_iterator<Iter,U> i )
-        {
-            return static_cast<U*>( *i.base() );
-        }
-
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return &*i;
-        }
-#endif        
-
-#if defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-        
-#else // BOOST_NO_SFINAE
-
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
-        template< class Iter >
-        static const U* get_const_pointer( void_ptr_iterator<Iter,U> i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-#else // BOOST_WORKAROUND
-        template< class Iter >
-        static const U* get_const_pointer( void_ptr_iterator<Iter,const U> i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-#endif // BOOST_WORKAROUND
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return &*i;
-        }
-#endif // BOOST_NO_SFINAE
-
-        BOOST_STATIC_CONSTANT(bool, allow_null = boost::is_nullable<T>::value );
-    };
-    
-} // ptr_container_detail
-
-
-    template< class Iterator, class T >
-    inline bool is_null( void_ptr_iterator<Iterator,T> i )
-    {
-        return *i.base() == 0;
-    }
-
-
-    
-    template
-    < 
-        class T,
-        class VoidPtrSeq, 
-        class CloneAllocator = heap_clone_allocator
-    >
-    class ptr_sequence_adapter : public 
-        ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>, 
-                                            CloneAllocator >
-    {
-        typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>,
-                                                    CloneAllocator >
-             base_type;
-        
-        typedef ptr_sequence_adapter<T,VoidPtrSeq,CloneAllocator>                         
-            this_type;
-
-    protected:
-        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter scoped_deleter;
-         
-    public:
-        typedef BOOST_DEDUCED_TYPENAME base_type::value_type  value_type; 
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference   reference; 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference 
-                                                              const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type   auto_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::clone_allocator_type
-                                                              clone_allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator    iterator;          
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type   size_type;  
-        typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type  
-                                                              allocator_type;
-                
-        ptr_sequence_adapter()
-        { }
-
-        template< class Allocator >
-        explicit ptr_sequence_adapter( const Allocator& a )
-          : base_type( a )
-        { }
-
-        template< class SizeType >
-        ptr_sequence_adapter( SizeType n, 
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class SizeType, class Allocator >
-        ptr_sequence_adapter( SizeType n, const Allocator& a, 
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, a, tag )
-        { }
-
-        template< class InputIterator >
-        ptr_sequence_adapter( InputIterator first, InputIterator last )
-          : base_type( first, last )
-        { }
-
-        template< class InputIterator, class Allocator >
-        ptr_sequence_adapter( InputIterator first, InputIterator last,
-                              const Allocator& a )
-          : base_type( first, last, a )
-        { }
-
-        template< class ForwardIterator >
-        ptr_sequence_adapter( ForwardIterator first,
-                              ForwardIterator last,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( first, last,  tag )
-        { }
-
-        template< class SizeType, class ForwardIterator >
-        ptr_sequence_adapter( SizeType n,
-                              ForwardIterator first,
-                              ForwardIterator last,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, first, last,  tag )
-        { }
-
-        ptr_sequence_adapter( const ptr_sequence_adapter& r )
-          : base_type( r )
-        { }
-        
-        template< class U >
-        ptr_sequence_adapter( const ptr_sequence_adapter<U,VoidPtrSeq,CloneAllocator>& r )
-          : base_type( r )
-        { }
-        
-        ptr_sequence_adapter( const ptr_sequence_adapter& r,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( r, tag )
-        { }
-        
-        template< class U >
-        ptr_sequence_adapter( const ptr_sequence_adapter<U,VoidPtrSeq,CloneAllocator>& r,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( r, tag )
-        { }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit ptr_sequence_adapter( std::auto_ptr<PtrContainer> clone )
-          : base_type( clone )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit ptr_sequence_adapter( std::unique_ptr<PtrContainer> clone )
-          : base_type( std::move( clone ) )
-        { }
-#endif
-
-        ptr_sequence_adapter& operator=( const ptr_sequence_adapter r )
-        {
-            this->swap( r );
-            return *this; 
-        }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        ptr_sequence_adapter& operator=( std::auto_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( clone );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        ptr_sequence_adapter& operator=( std::unique_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( std::move( clone ) );
-            return *this;
-        }
-#endif
-
-        /////////////////////////////////////////////////////////////
-        // modifiers
-        /////////////////////////////////////////////////////////////
-
-        void push_back( value_type x )  // strong               
-        {
-            this->enforce_null_policy( x, "Null pointer in 'push_back()'" );
-            auto_type ptr( x, *this );    // notrow
-            this->base().push_back( x );  // strong, commit
-            ptr.release();                // nothrow
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        void push_back( std::auto_ptr<U> x )
-        {
-            push_back( x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        void push_back( std::unique_ptr<U> x )
-        {
-            push_back( x.release() );
-        }
-#endif
-        
-        void push_front( value_type x )                
-        {
-            this->enforce_null_policy( x, "Null pointer in 'push_front()'" );
-            auto_type ptr( x, *this );    // nothrow            
-            this->base().push_front( x ); // strong, commit
-            ptr.release();                // nothrow
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        void push_front( std::auto_ptr<U> x )
-        {
-            push_front( x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        void push_front( std::unique_ptr<U> x )
-        {
-            push_front( x.release() );
-        }
-#endif
-
-        auto_type pop_back()
-        {
-            BOOST_ASSERT( !this->empty() && 
-                          "'pop_back()' on empty container" );
-            auto_type ptr( static_cast<value_type>(this->base().back()), *this );      
-                                                       // nothrow
-            this->base().pop_back();                   // nothrow
-            return ptr_container_detail::move( ptr );  // nothrow
-        }
-
-        auto_type pop_front()
-        {
-            BOOST_ASSERT( !this->empty() &&
-                          "'pop_front()' on empty container" ); 
-            auto_type ptr( static_cast<value_type>(this->base().front()), *this ); 
-                                         // nothrow 
-            this->base().pop_front();    // nothrow
-            return ptr_container_detail::move( ptr ); 
-        }
-        
-        reference front()        
-        { 
-            BOOST_ASSERT( !this->empty() &&
-                          "accessing 'front()' on empty container" );
-
-            BOOST_ASSERT( !::boost::is_null( this->begin() ) );
-            return *this->begin(); 
-        }
-
-        const_reference front() const  
-        {
-            return const_cast<ptr_sequence_adapter*>(this)->front();
-        }
-
-        reference back()
-        {
-            BOOST_ASSERT( !this->empty() &&
-                          "accessing 'back()' on empty container" );
-            BOOST_ASSERT( !::boost::is_null( --this->end() ) );
-            return *--this->end(); 
-        }
-
-        const_reference back() const
-        {
-            return const_cast<ptr_sequence_adapter*>(this)->back();
-        }
-
-    public: // deque/vector inerface
-        
-        reference operator[]( size_type n ) // nothrow 
-        {
-            BOOST_ASSERT( n < this->size() );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return *static_cast<value_type>( this->base()[n] ); 
-        }
-        
-        const_reference operator[]( size_type n ) const // nothrow  
-        { 
-            BOOST_ASSERT( n < this->size() ); 
-            BOOST_ASSERT( !this->is_null( n ) );
-            return *static_cast<value_type>( this->base()[n] );
-        }
-        
-        reference at( size_type n )
-        {
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( n >= this->size(), bad_index, 
-                                                 "'at()' out of bounds" );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return (*this)[n];
-        }
-        
-        const_reference at( size_type n ) const
-        {
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( n >= this->size(), bad_index, 
-                                                 "'at()' out of bounds" );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return (*this)[n]; 
-        }
-        
-    public: // vector interface
-        
-        size_type capacity() const
-        {
-            return this->base().capacity();
-        }
-        
-        void reserve( size_type n )
-        {
-            this->base().reserve( n ); 
-        }
-
-        void reverse()
-        {
-            this->base().reverse(); 
-        }
-
-    public: // assign, insert, transfer
-
-        // overhead: 1 heap allocation (very cheap compared to cloning)
-        template< class InputIterator >
-        void assign( InputIterator first, InputIterator last ) // strong
-        { 
-            base_type temp( first, last );
-            this->swap( temp );
-        }
-
-        template< class Range >
-        void assign( const Range& r ) // strong
-        {
-            assign( boost::begin(r), boost::end(r ) );
-        }
-
-    private:
-        template< class I >
-        void insert_impl( iterator before, I first, I last, std::input_iterator_tag ) // strong
-        {
-            ptr_sequence_adapter temp(first,last);  // strong
-            transfer( before, temp );               // strong, commit
-        }
-
-        template< class I >
-        void insert_impl( iterator before, I first, I last, std::forward_iterator_tag ) // strong
-        {
-            if( first == last ) 
-                return;
-            scoped_deleter sd( *this, first, last );         // strong
-            this->insert_clones_and_release( sd, before );   // strong, commit 
-        }
-
-    public:
-
-        using base_type::insert;
-        
-        template< class InputIterator >
-        void insert( iterator before, InputIterator first, InputIterator last ) // strong
-        {
-            insert_impl( before, first, last, BOOST_DEDUCED_TYPENAME
-                         iterator_category<InputIterator>::type() );
-        } 
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( iterator before, const Range& r )
-        {
-            insert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-        
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, 
-                       PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().
-                insert( before.base(), first.base(), last.base() ); // strong
-            from.base().erase( first.base(), last.base() );         // nothrow
-        }
-
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, 
-                       PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().insert( before.base(), *object.base() ); // strong 
-            from.base().erase( object.base() );                  // nothrow 
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        
-        template< class PtrSeqAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                      BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type
-        transfer( iterator before, const Range& r, PtrSeqAdapter& from ) // strong
-        {
-            transfer( before, boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().
-                insert( before.base(),
-                        from.begin().base(), from.end().base() ); // strong
-            from.base().clear();                                  // nothrow
-        }
-
-    public: // C-array support
-    
-        void transfer( iterator before, value_type* from, 
-                       size_type size, bool delete_from = true ) // strong 
-        {
-            BOOST_ASSERT( from != 0 );
-            if( delete_from )
-            {
-                BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
-                    deleter( *this, from, size );                         // nothrow
-                this->base().insert( before.base(), from, from + size );  // strong
-                deleter.release();                                        // nothrow
-            }
-            else
-            {
-                this->base().insert( before.base(), from, from + size ); // strong
-            }
-        }
-
-        value_type* c_array() // nothrow
-        {
-            if( this->empty() )
-                return 0;
-            T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
-            return res;
-        }
-
-    public: // null functions
-         
-        bool is_null( size_type idx ) const
-        {
-            BOOST_ASSERT( idx < this->size() );
-            return this->base()[idx] == 0;
-        }
-
-    public: // resize
-
-        void resize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( new BOOST_DEDUCED_TYPENAME 
-                                     boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void resize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );        
-        }
-
-        void rresize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( new BOOST_DEDUCED_TYPENAME 
-                                      boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void rresize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }           
-                
-    public: // algorithms
-
-        void sort( iterator first, iterator last )
-        {
-            sort( first, last, std::less<T>() );
-        }
-        
-        void sort()
-        {
-            sort( this->begin(), this->end() );
-        }
-
-        template< class Compare >
-        void sort( iterator first, iterator last, Compare comp )
-        {
-            BOOST_ASSERT( first <= last && "out of range sort()" );
-            BOOST_ASSERT( this->begin() <= first && "out of range sort()" );
-            BOOST_ASSERT( last <= this->end() && "out of range sort()" ); 
-            // some static assert on the arguments of the comparison
-            std::sort( first.base(), last.base(), 
-                       void_ptr_indirect_fun<Compare,T>(comp) );
-        }
-        
-        template< class Compare >
-        void sort( Compare comp )
-        {
-            sort( this->begin(), this->end(), comp );
-        }
-        
-        void unique( iterator first, iterator last )
-        {
-            unique( first, last, std::equal_to<T>() );
-        }
-        
-        void unique()
-        {
-            unique( this->begin(), this->end() );
-        }
-
-    private:
-        struct is_not_zero_ptr
-        {
-            template< class U >
-            bool operator()( const U* r ) const
-            {
-                return r != 0;
-            }
-        };
-
-    protected:
-        template< class Fun, class Arg1 >
-        class void_ptr_delete_if 
-        {
-            Fun fun;
-        public:
-        
-            void_ptr_delete_if() : fun(Fun())
-            { }
-        
-            void_ptr_delete_if( Fun f ) : fun(f)
-            { }
-        
-            bool operator()( void* r ) const
-            {
-               BOOST_ASSERT( r != 0 );
-               Arg1 arg1 = static_cast<Arg1>(r);
-               if( fun( *arg1 ) )
-               { 
-                   clone_allocator_type::deallocate_clone( arg1 );
-                   return true;
-               }
-               return false;
-            }
-        };
-
-    private:
-        void compact_and_erase_nulls( iterator first, iterator last ) // nothrow
-        {
-            typename base_type::ptr_iterator p = std::stable_partition( 
-                                                    first.base(), 
-                                                    last.base(), 
-                                                    is_not_zero_ptr() );
-            this->base().erase( p, this->end().base() );
-            
-        }
-
-        void range_check_impl( iterator, iterator, 
-                               std::bidirectional_iterator_tag )
-        { /* do nothing */ }
-
-        void range_check_impl( iterator first, iterator last,
-                               std::random_access_iterator_tag )
-        {
-            BOOST_ASSERT( first <= last && "out of range unique()/erase_if()" );
-            BOOST_ASSERT( this->begin() <= first && "out of range unique()/erase_if()" );
-            BOOST_ASSERT( last <= this->end() && "out of range unique()/erase_if)(" );             
-        }
-        
-        void range_check( iterator first, iterator last )
-        {
-            range_check_impl( first, last, 
-                              BOOST_DEDUCED_TYPENAME iterator_category<iterator>::type() );
-        }
-        
-    public:
-        
-        template< class Compare >
-        void unique( iterator first, iterator last, Compare comp )
-        {
-            range_check(first,last);
-            
-            iterator prev = first;
-            iterator next = first;
-            ++next;
-            for( ; next != last; ++next )
-            {
-                BOOST_ASSERT( !::boost::is_null(prev) );
-                BOOST_ASSERT( !::boost::is_null(next) );
-                if( comp( *prev, *next ) )
-                {
-                    this->remove( next ); // delete object
-                    *next.base() = 0;     // mark pointer as deleted
-                }
-                else
-                {
-                    prev = next;
-                }
-                // ++next
-            }
-
-            compact_and_erase_nulls( first, last );
-        }
-        
-        template< class Compare >
-        void unique( Compare comp )
-        {
-            unique( this->begin(), this->end(), comp );
-        }
-
-        template< class Pred >
-        void erase_if( iterator first, iterator last, Pred pred )
-        {
-            range_check(first,last);
-            this->base().erase( std::remove_if( first.base(), last.base(), 
-                                                void_ptr_delete_if<Pred,value_type>(pred) ),
-                                last.base() );  
-        }
-        
-        template< class Pred >
-        void erase_if( Pred pred )
-        {
-            erase_if( this->begin(), this->end(), pred );
-        }
-
-
-        void merge( iterator first, iterator last, 
-                    ptr_sequence_adapter& from )
-        {
-             merge( first, last, from, std::less<T>() );
-        }
-        
-        template< class BinPred >
-        void merge( iterator first, iterator last, 
-                    ptr_sequence_adapter& from, BinPred pred )
-        {
-            void_ptr_indirect_fun<BinPred,T>  bin_pred(pred);
-            size_type                         current_size = this->size(); 
-            this->transfer( this->end(), first, last, from );
-            typename base_type::ptr_iterator middle = this->begin().base();
-            std::advance(middle,current_size); 
-            std::inplace_merge( this->begin().base(),
-                                middle,
-                                this->end().base(),
-                                bin_pred );
-        }
-        
-        void merge( ptr_sequence_adapter& r )
-        {
-            merge( r, std::less<T>() );
-            BOOST_ASSERT( r.empty() );
-        }
-        
-        template< class BinPred >
-        void merge( ptr_sequence_adapter& r, BinPred pred )
-        {
-            merge( r.begin(), r.end(), r, pred );
-            BOOST_ASSERT( r.empty() );    
-        }
-        
-    };
-
-
-} // namespace 'boost'  
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_set.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_set.hpp
deleted file mode 100644
index a57167549a..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_set.hpp
+++ /dev/null
@@ -1,168 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SET_HPP
-#define BOOST_PTR_CONTAINER_PTR_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/ptr_set_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <set>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    template
-    < 
-        class Key, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<typename ptr_container_detail::void_ptr<Key>::type>
-    >
-    class ptr_set : 
-        public ptr_set_adapter< Key, std::set<
-            typename ptr_container_detail::void_ptr<Key>::type,
-            void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                CloneAllocator, true >
-    {
-        typedef ptr_set_adapter< Key, std::set<
-            typename ptr_container_detail::void_ptr<Key>::type,
-            void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                 CloneAllocator, true >
-             base_type;
-
-        typedef ptr_set<Key,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_set()
-        { }
-        
-        explicit ptr_set( const Compare& comp,
-                          const Allocator& a = Allocator() ) 
-         : base_type( comp, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_set( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_set( InputIterator first, InputIterator last, 
-                 const Compare& comp,
-                 const Allocator& a = Allocator() ) 
-         : base_type( first, last, comp, a )
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_set,
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_set, base_type )
-                
-    };
-        
-        
-        
-    template
-    < 
-        class Key, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_multiset : 
-        public ptr_multiset_adapter< Key,
-                                     std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                     CloneAllocator, true >
-    {
-        typedef ptr_multiset_adapter< Key,
-                                      std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                      CloneAllocator, true >
-              base_type;
-        typedef ptr_multiset<Key,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_multiset()
-        { }
-        
-        explicit ptr_multiset( const Compare& comp,
-                               const Allocator& a    = Allocator() )
-         : base_type( comp, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_multiset( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_multiset( InputIterator first, InputIterator last,
-                      const Compare& comp,
-                      const Allocator& a  = Allocator() )
-         : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multiset, 
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_multiset, 
-                                                      base_type )     
-
-    };
-
-    /////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename K, typename C, typename CA, typename A >
-    inline ptr_set<K,C,CA,A>* new_clone( const ptr_set<K,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< typename K, typename C, typename CA, typename A >
-    inline ptr_multiset<K,C,CA,A>* new_clone( const ptr_multiset<K,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename C, typename CA, typename A >
-    inline void swap( ptr_set<K,C,CA,A>& l, ptr_set<K,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename C, typename CA, typename A >
-    inline void swap( ptr_multiset<K,C,CA,A>& l, ptr_multiset<K,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_set_adapter.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_set_adapter.hpp
deleted file mode 100644
index c4d99d135b..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_set_adapter.hpp
+++ /dev/null
@@ -1,798 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/associative_ptr_container.hpp>
-#include <boost/ptr_container/detail/meta_functions.hpp>
-#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <boost/range/iterator_range.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-    template
-    < 
-        class Key,
-        class VoidPtrSet,
-        bool  Ordered
-    >
-    struct set_config
-    {
-       typedef VoidPtrSet 
-                    void_container_type;
-
-       typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type 
-                    allocator_type;
-
-       typedef Key  value_type;
-
-       typedef value_type 
-                    key_type;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_value_compare<VoidPtrSet>, 
-                          mpl::identity<void> >::type
-                    value_compare;
-
-       typedef value_compare 
-                    key_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_hasher<VoidPtrSet> >::type
-                    hasher;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_key_equal<VoidPtrSet> >::type
-                    key_equal;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::if_c<Ordered,
-                     ordered_associative_container_tag,
-                     unordered_associative_container_tag>::type
-                    container_type;
-
-       typedef void_ptr_iterator<
-                       BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > 
-                    iterator;
-
-       typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
-                    const_iterator;
-
-       typedef void_ptr_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrSet>,
-                            select_local_iterator<VoidPtrSet> >::type,
-             Key >
-                    local_iterator;
-
-       typedef void_ptr_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrSet>,
-                            select_const_local_iterator<VoidPtrSet> >::type,
-             const Key >
-                    const_local_iterator;           
-       
-       template< class Iter >
-       static Key* get_pointer( Iter i )
-       {
-           return static_cast<Key*>( *i.base() );
-       }
-
-       template< class Iter >
-       static const Key* get_const_pointer( Iter i )
-       {
-           return static_cast<const Key*>( *i.base() );
-       }
-
-       BOOST_STATIC_CONSTANT(bool, allow_null = false );
-    };
-
- 
-    
-    template
-    < 
-        class Key,
-        class VoidPtrSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_set_adapter_base 
-        : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
-                                                      CloneAllocator >
-    {
-        typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
-                                                     CloneAllocator >
-              base_type;
-    public:  
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator 
-                      iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator 
-                      const_iterator;
-        typedef Key   key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                      size_type;
-
-    public:
-        ptr_set_adapter_base() 
-        { }
-
-        template< class SizeType >
-        ptr_set_adapter_base( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-                
-        template< class Compare, class Allocator >
-        ptr_set_adapter_base( const Compare& comp,
-                              const Allocator& a ) 
-         : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_set_adapter_base( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        ptr_set_adapter_base( InputIterator first, InputIterator last,
-                              const Compare& comp,
-                              const Allocator& a ) 
-         : base_type( first, last, comp, a ) 
-        { }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_set_adapter_base( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-               
-        template< class U, class Set, class CA, bool b >
-        ptr_set_adapter_base( const ptr_set_adapter_base<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-
-        ptr_set_adapter_base( const ptr_set_adapter_base& r )
-          : base_type( r )
-        { }
-                
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit ptr_set_adapter_base( std::unique_ptr<PtrContainer> clone )
-         : base_type( std::move( clone ) )
-        { }
-#endif
-        
-        ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) 
-        {
-            this->swap( r );
-            return *this;
-        }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< typename PtrContainer >
-        ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( clone );
-            return *this;
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< typename PtrContainer >
-        ptr_set_adapter_base& operator=( std::unique_ptr<PtrContainer> clone )
-        {
-            base_type::operator=( std::move( clone ) );
-            return *this;
-        }
-#endif
-
-        using base_type::erase;
-        
-        size_type erase( const key_type& x ) // nothrow
-        {
-            key_type* key = const_cast<key_type*>(&x);
-            iterator i( this->base().find( key ) );       
-            if( i == this->end() )                                  // nothrow
-                return 0u;                                          // nothrow
-            key = static_cast<key_type*>(*i.base());                // nothrow
-            size_type res = this->base().erase( key );              // nothrow 
-            this->remove( key );                                    // nothrow
-            return res;
-        }
-
-
-        iterator find( const key_type& x )                                                
-        {                                                                            
-            return iterator( this->base().
-                             find( const_cast<key_type*>(&x) ) );            
-        }                                                                            
-
-        const_iterator find( const key_type& x ) const                                    
-        {                                                                            
-            return const_iterator( this->base().
-                                   find( const_cast<key_type*>(&x) ) );                  
-        }                                                                            
-
-        size_type count( const key_type& x ) const                                        
-        {                                                                            
-            return this->base().count( const_cast<key_type*>(&x) );                      
-        }                                                                            
-                                                                                     
-        iterator lower_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().
-                             lower_bound( const_cast<key_type*>(&x) ) );                   
-        }                                                                            
-                                                                                     
-        const_iterator lower_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().
-                                   lower_bound( const_cast<key_type*>(&x) ) );       
-        }                                                                            
-                                                                                     
-        iterator upper_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().
-                             upper_bound( const_cast<key_type*>(&x) ) );           
-        }                                                                            
-                                                                                     
-        const_iterator upper_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().
-                                   upper_bound( const_cast<key_type*>(&x) ) );             
-        }                                                                            
-                                                                                     
-        iterator_range<iterator> equal_range( const key_type& x )                    
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> 
-                p = this->base().
-                equal_range( const_cast<key_type*>(&x) );   
-            return make_iterator_range( iterator( p.first ), 
-                                        iterator( p.second ) );      
-        }                                                                            
-                                                                                     
-        iterator_range<const_iterator> equal_range( const key_type& x ) const  
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 
-                p = this->base().
-                equal_range( const_cast<key_type*>(&x) ); 
-            return make_iterator_range( const_iterator( p.first ), 
-                                        const_iterator( p.second ) );    
-        }    
-
-    protected:
-        size_type bucket( const key_type& key ) const
-        {
-            return this->base().bucket( const_cast<key_type*>(&key) );
-        }
-    };
-
-} // ptr_container_detail
-
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_set_adapter
-    /////////////////////////////////////////////////////////////////////////
-  
-    template
-    <
-        class Key,
-        class VoidPtrSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_set_adapter : 
-        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered> 
-            base_type;
-    
-    public: // typedefs
-       
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator
-                     iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                     const_iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                     size_type;    
-        typedef Key  key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                     auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
-                     allocator_type;        
-    private:
-        
-        template< typename II >                                               
-        void set_basic_clone_and_insert( II first, II last ) // basic                 
-        {                                                                     
-            while( first != last )                                            
-            {           
-                if( this->find( *first ) == this->end() )
-                    insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit
-                ++first;                                                      
-            }                                                                 
-        }                         
-
-    public:
-        ptr_set_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_set_adapter( SizeType n, 
-                         ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-        
-        template< class Comp >
-        explicit ptr_set_adapter( const Comp& comp,
-                                  const allocator_type& a ) 
-          : base_type( comp, a ) 
-        {
-            BOOST_ASSERT( this->empty() ); 
-        }
-
-        template< class SizeType, class Hash, class Pred, class Allocator >
-        ptr_set_adapter( SizeType n,
-                         const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-         : base_type( n, hash, pred, a )
-        { }
-        
-        template< class Hash, class Pred, class Allocator >
-        ptr_set_adapter( const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_set_adapter( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        ptr_set_adapter( InputIterator first, InputIterator last, 
-                         const Compare& comp,
-                         const Allocator a = Allocator() )
-          : base_type( comp, a )
-        {
-            BOOST_ASSERT( this->empty() );
-            set_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_set_adapter( InputIterator first, InputIterator last,
-                         const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-          : base_type( first, last, hash, pred, a )
-        { }
-
-        explicit ptr_set_adapter( const ptr_set_adapter& r )
-          : base_type( r )
-        { }
-
-        template< class U, class Set, class CA, bool b >
-        explicit ptr_set_adapter( const ptr_set_adapter<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit ptr_set_adapter( std::unique_ptr<PtrContainer> clone )
-         : base_type( std::move( clone ) )
-        { }
-#endif
-
-        template< class U, class Set, class CA, bool b >
-        ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r ) 
-        {
-            base_type::operator=( r );
-            return *this;
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class T >
-        void operator=( std::auto_ptr<T> r )
-        {
-            base_type::operator=( r );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class T >
-        void operator=( std::unique_ptr<T> r )
-        {
-            base_type::operator=( std::move( r ) );
-        }
-#endif
-
-        std::pair<iterator,bool> insert( key_type* x ) // strong                      
-        {       
-            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
-            
-            auto_type ptr( x, *this );                                
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                 res = this->base().insert( x );       
-            if( res.second )                                                 
-                ptr.release();                                                  
-            return std::make_pair( iterator( res.first ), res.second );     
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        std::pair<iterator,bool> insert( std::auto_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        std::pair<iterator,bool> insert( std::unique_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-#endif
-
-        
-        iterator insert( iterator where, key_type* x ) // strong
-        {
-            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
-
-            auto_type ptr( x, *this );                                
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator 
-                res = this->base().insert( where.base(), x );
-            if( *res == x )                                                 
-                ptr.release();                                                  
-            return iterator( res);
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator where, std::auto_ptr<U> x )
-        {
-            return insert( where, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator where, std::unique_ptr<U> x )
-        {
-            return insert( where, x.release() );
-        }
-#endif
-        
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-#endif        
-
-        template< class PtrSetAdapter >
-        bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
-                       PtrSetAdapter& from ) // strong
-        {
-            return this->single_transfer( object, from );
-        }
-
-        template< class PtrSetAdapter >
-        size_type 
-        transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
-                  BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
-                  PtrSetAdapter& from ) // basic
-        {
-            return this->single_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template< class PtrSetAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrSetAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-
-        template< class PtrSetAdapter >
-        size_type transfer( PtrSetAdapter& from ) // basic
-        {
-            return transfer( from.begin(), from.end(), from );
-        }
-
-    };
-    
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_multiset_adapter
-    /////////////////////////////////////////////////////////////////////////
-
-    template
-    < 
-        class Key,
-        class VoidPtrMultiSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool Ordered         = true 
-    >
-    class ptr_multiset_adapter : 
-        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered>
-    {
-         typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type;
-    
-    public: // typedefs
-    
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator   
-                       iterator;          
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                       size_type;
-        typedef Key    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                       auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type
-                       allocator_type;        
-    private:
-        template< typename II >                                               
-        void set_basic_clone_and_insert( II first, II last ) // basic                 
-        {               
-            while( first != last )                                            
-            {           
-                insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit                              
-                ++first;                                                     
-            }                                                                 
-        }                         
-    
-    public:
-        ptr_multiset_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_multiset_adapter( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Comp >
-        explicit ptr_multiset_adapter( const Comp& comp,
-                                       const allocator_type& a )
-        : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_multiset_adapter( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_multiset_adapter( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< class InputIterator, class Comp >
-        ptr_multiset_adapter( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a = allocator_type() )
-        : base_type( comp, a ) 
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_multiset_adapter( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-                
-        template< class U, class Set, class CA, bool b >
-        explicit ptr_multiset_adapter( const ptr_multiset_adapter<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class PtrContainer >
-        explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class PtrContainer >
-        explicit ptr_multiset_adapter( std::unique_ptr<PtrContainer> clone )
-         : base_type( std::move( clone ) )
-        { }
-#endif
-
-        template< class U, class Set, class CA, bool b >
-        ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r ) 
-        {
-            base_type::operator=( r );
-            return *this;
-        }
-        
-#ifndef BOOST_NO_AUTO_PTR
-        template< class T >
-        void operator=( std::auto_ptr<T> r ) 
-        {
-            base_type::operator=( r ); 
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class T >
-        void operator=( std::unique_ptr<T> r ) 
-        {
-            base_type::operator=( std::move( r ) ); 
-        }
-#endif
-
-        iterator insert( iterator before, key_type* x ) // strong  
-        {
-            return base_type::insert( before, x ); 
-        } 
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( iterator before, std::auto_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( iterator before, std::unique_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-#endif
-    
-        iterator insert( key_type* x ) // strong                                      
-        {   
-            this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
-    
-            auto_type ptr( x, *this );                                
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                 res = this->base().insert( x );                         
-            ptr.release();                                                      
-            return iterator( res );                                             
-        }
-
-#ifndef BOOST_NO_AUTO_PTR
-        template< class U >
-        iterator insert( std::auto_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-#endif
-#ifndef BOOST_NO_CXX11_SMART_PTR
-        template< class U >
-        iterator insert( std::unique_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-#endif
-    
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-        template< class PtrSetAdapter >
-        void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
-                       PtrSetAdapter& from ) // strong
-        {
-            this->multi_transfer( object, from );
-        }
-
-        template< class PtrSetAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
-                            PtrSetAdapter& from ) // basic
-        {
-            return this->multi_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class PtrSetAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                       BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type
-        transfer(  const Range& r, PtrSetAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif        
-
-        template< class PtrSetAdapter >
-        void transfer( PtrSetAdapter& from ) // basic
-        {
-            transfer( from.begin(), from.end(), from );
-            BOOST_ASSERT( from.empty() );
-        }
-        
-    };
-
-} // namespace 'boost'  
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_unordered_map.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_unordered_map.hpp
deleted file mode 100644
index dc90cd8c5b..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_unordered_map.hpp
+++ /dev/null
@@ -1,261 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_UNORDERED_MAP_HPP
-#define BOOST_PTR_CONTAINER_PTR_UNORDERED_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/unordered_map.hpp>
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-    
-    template
-    < 
-        class Key, 
-        class T, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,
-                           typename ptr_container_detail::void_ptr<T>::type> >
-    >
-    class ptr_unordered_map : 
-        public ptr_map_adapter<T,boost::unordered_map<Key,
-            typename ptr_container_detail::void_ptr<T>::type,Hash,Pred,Allocator>,
-                               CloneAllocator,false>
-    {
-        typedef ptr_map_adapter<T,boost::unordered_map<Key,
-            typename ptr_container_detail::void_ptr<T>::type,Hash,Pred,Allocator>,
-                               CloneAllocator,false>
-            base_type;
-
-        typedef ptr_unordered_map<Key,T,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-        
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_map()
-        { }
-
-        explicit ptr_unordered_map( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_map( size_type n,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),                                         
-                           const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_map( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< typename InputIterator >
-        ptr_unordered_map( InputIterator first, InputIterator last,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),
-                           const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_map, 
-                                                      base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_unordered_map( const ptr_unordered_map<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_unordered_map& operator=( ptr_unordered_map r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-
-
-    template
-    < 
-        class Key, 
-        class T, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_unordered_multimap : 
-        public ptr_multimap_adapter<T,boost::unordered_multimap<Key,void*,Hash,Pred,Allocator>,
-                                    CloneAllocator,false>
-    {
-        typedef ptr_multimap_adapter<T,boost::unordered_multimap<Key,void*,Hash,Pred,Allocator>,
-                                     CloneAllocator,false>
-            base_type;
-
-        typedef ptr_unordered_multimap<Key,T,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-        
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_multimap()
-        { }
-
-        explicit ptr_unordered_multimap( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_multimap( size_type n,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),                                         
-                                const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multimap( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< typename InputIterator >
-        ptr_unordered_multimap( InputIterator first, InputIterator last,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),
-                                const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_multimap, 
-                                                      base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_unordered_multimap( const ptr_unordered_multimap<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_unordered_multimap& operator=( ptr_unordered_multimap r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline ptr_unordered_map<K,T,H,P,CA,A>* 
-    new_clone( const ptr_unordered_map<K,T,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline ptr_unordered_multimap<K,T,H,P,CA,A>* 
-    new_clone( const ptr_unordered_multimap<K,T,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline void swap( ptr_unordered_map<K,T,H,P,CA,A>& l, 
-                      ptr_unordered_map<K,T,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline void swap( ptr_unordered_multimap<K,T,H,P,CA,A>& l, 
-                      ptr_unordered_multimap<K,T,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_unordered_set.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_unordered_set.hpp
deleted file mode 100644
index 6660722595..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_unordered_set.hpp
+++ /dev/null
@@ -1,252 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_UNORDERED_SET_HPP
-#define BOOST_PTR_CONTAINER_PTR_UNORDERED_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/ptr_set_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-#include <boost/unordered_set.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    template
-    < 
-        class Key, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< typename ptr_container_detail::void_ptr<Key>::type >
-    >
-    class ptr_unordered_set : 
-        public ptr_set_adapter< Key, boost::unordered_set<
-            typename ptr_container_detail::void_ptr<Key>::type,
-            void_ptr_indirect_fun<Hash,Key>,
-            void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                CloneAllocator, false >
-    {
-        typedef ptr_set_adapter< Key, boost::unordered_set<
-                           typename ptr_container_detail::void_ptr<Key>::type,
-                                 void_ptr_indirect_fun<Hash,Key>,
-                                 void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                 CloneAllocator, false >
-             base_type;
-
-        typedef ptr_unordered_set<Key,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_set()
-        {}
-
-        explicit ptr_unordered_set( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_set( size_type n,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),                                         
-                           const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_set( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_set( InputIterator first, InputIterator last,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),
-                           const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_set,
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_unordered_set, 
-                                                      base_type )
-                
-    };
-        
-        
-    template
-    < 
-        class Key, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_unordered_multiset : 
-          public ptr_multiset_adapter< Key, 
-                                boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>,
-                                                                void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                            CloneAllocator, false >
-    {
-      typedef ptr_multiset_adapter< Key, 
-              boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>,
-                                        void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                        CloneAllocator, false >
-              base_type;
-        typedef ptr_unordered_multiset<Key,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_multiset()
-        { }
-        
-        explicit ptr_unordered_multiset( size_type n )
-         : base_type( n, ptr_container_detail::unordered_associative_container_tag() ) 
-        { }
-
-        ptr_unordered_multiset( size_type n,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),                                         
-                                const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multiset( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multiset( InputIterator first, InputIterator last,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),
-                                const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_multiset, 
-                                                      base_type,
-                                                      this_type )
-         
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_unordered_multiset, 
-                                                      base_type )     
-
-    };
-
-    /////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline ptr_unordered_set<K,H,P,CA,A>* 
-    new_clone( const ptr_unordered_set<K,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline ptr_unordered_multiset<K,H,P,CA,A>* 
-    new_clone( const ptr_unordered_multiset<K,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline void swap( ptr_unordered_set<K,H,P,CA,A>& l, 
-                      ptr_unordered_set<K,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline void swap( ptr_unordered_multiset<K,H,P,CA,A>& l, 
-                      ptr_unordered_multiset<K,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/ptr_vector.hpp b/contrib/restricted/boost/boost/ptr_container/ptr_vector.hpp
deleted file mode 100644
index d3ecdf88ec..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/ptr_vector.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_VECTOR_HPP
-#define BOOST_PTR_CONTAINER_PTR_VECTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <vector>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<typename ptr_container_detail::void_ptr<T>::type>
-    >
-    class ptr_vector : public 
-        ptr_sequence_adapter< T, std::vector<
-            typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                              CloneAllocator >
-    {  
-        typedef ptr_sequence_adapter< T, std::vector<
-            typename ptr_container_detail::void_ptr<T>::type,Allocator>, 
-                                      CloneAllocator > 
-            base_class;
-
-        typedef ptr_vector<T,CloneAllocator,Allocator> this_type;
-        
-    public:
-
-        BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_vector, 
-                                                      base_class,
-                                                      this_type )
-        
-        explicit ptr_vector( size_type n,
-                             const allocator_type& alloc = allocator_type() )
-          : base_class(alloc)
-        {
-            this->base().reserve( n );
-        }        
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_vector<T,CA,A>* new_clone( const ptr_vector<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_vector<T,CA,A>& l, ptr_vector<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-    
-}
-
-#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
-#pragma GCC diagnostic pop
-#endif
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_array.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_array.hpp
deleted file mode 100644
index a602016adf..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_array.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_ARRAY_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_ARRAY_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_array.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void save(Archive& ar, const ptr_array<T, N, CloneAllocator>& c, unsigned int /*version*/)
-{
-    ptr_container_detail::save_helper(ar, c);
-}
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void load(Archive& ar, ptr_array<T, N, CloneAllocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_array<T, N, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    for(size_type i = 0u; i != N; ++i)
-    {
-        T* p;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::item(), p );
-        c.replace(i, p);
-    }
-}
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void serialize(Archive& ar, ptr_array<T, N, CloneAllocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_circular_buffer.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_circular_buffer.hpp
deleted file mode 100644
index 019a8b5a1f..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_circular_buffer.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_CIRCULAR_BUFFER_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_CIRCULAR_BUFFER_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_circular_buffer.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void load(Archive& ar, ptr_circular_buffer<T, CloneAllocator, Allocator>& c, unsigned int version)
-{
-    typedef ptr_circular_buffer<T, CloneAllocator, Allocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    c.reserve(n);
-    
-    ptr_container_detail::load_helper(ar, c, n);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_circular_buffer<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_container.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_container.hpp
deleted file mode 100644
index 22ab592cc2..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_container.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_HPP
-
-#include <boost/ptr_container/serialize_ptr_array.hpp>
-#include <boost/ptr_container/serialize_ptr_deque.hpp>
-#include <boost/ptr_container/serialize_ptr_list.hpp>
-#include <boost/ptr_container/serialize_ptr_map.hpp>
-#include <boost/ptr_container/serialize_ptr_set.hpp>
-#include <boost/ptr_container/serialize_ptr_vector.hpp>
-#include <boost/ptr_container/serialize_ptr_unordered_set.hpp>
-#include <boost/ptr_container/serialize_ptr_unordered_map.hpp>
-#include <boost/ptr_container/serialize_ptr_circular_buffer.hpp>
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_deque.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_deque.hpp
deleted file mode 100644
index fe1b5c46d4..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_deque.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_DEQUE_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_DEQUE_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_deque.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_deque<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_list.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_list.hpp
deleted file mode 100644
index e25f26445d..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_list.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_LIST_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_LIST_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_list.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_list<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_map.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_map.hpp
deleted file mode 100644
index ee7439d107..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_map.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_MAP_HPP
-
-#include <boost/ptr_container/detail/serialize_ptr_map_adapter.hpp>
-#include <boost/ptr_container/ptr_map.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class Key, class T, class Compare, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_map<Key, T, Compare, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class Key, class T, class Compare, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_multimap<Key, T, Compare, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_set.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_set.hpp
deleted file mode 100644
index 6c9dfd5b06..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_set.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_SET_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_SET_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_set.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_set<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_multiset<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_map.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_map.hpp
deleted file mode 100644
index 1dcf842596..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_map.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_UNORDERED_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_UNORDERED_PTR_MAP_HPP
-
-#include <boost/ptr_container/detail/serialize_ptr_map_adapter.hpp>
-#include <boost/ptr_container/ptr_unordered_map.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class Key, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_map<Key, T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class Key, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_multimap<Key, T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_set.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_set.hpp
deleted file mode 100644
index ac0f5f6d79..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_unordered_set.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. Use, modification and
-//  distribution is subject to 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)
-//
-// For more information, see http://www.boost.org/libs/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_UNORDERED_SET_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_UNORDERED_SET_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_unordered_set.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_set<T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_multiset<T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_vector.hpp b/contrib/restricted/boost/boost/ptr_container/serialize_ptr_vector.hpp
deleted file mode 100644
index a25066a8e8..0000000000
--- a/contrib/restricted/boost/boost/ptr_container/serialize_ptr_vector.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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)
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_VECTOR_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_VECTOR_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_vector.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void load(Archive& ar, ptr_vector<T, CloneAllocator, Allocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_vector<T, CloneAllocator, Allocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    c.reserve(n);
-    
-    ptr_container_detail::load_helper(ar, c, n);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_vector<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/restricted/boost/ptr_container/CMakeLists.txt b/contrib/restricted/boost/ptr_container/CMakeLists.txt
new file mode 100644
index 0000000000..a173adc428
--- /dev/null
+++ b/contrib/restricted/boost/ptr_container/CMakeLists.txt
@@ -0,0 +1,31 @@
+
+# This file was gererated by the build system used internally in the Yandex monorepo.
+# Only simple modifications are allowed (adding source-files to targets, adding simple properties
+# like target_include_directories). These modifications will be ported to original
+# ya.make files by maintainers. Any complex modifications which can't be ported back to the
+# original buildsystem will not be accepted.
+
+
+
+add_library(restricted-boost-ptr_container INTERFACE)
+target_include_directories(restricted-boost-ptr_container INTERFACE
+  ${CMAKE_SOURCE_DIR}/contrib/restricted/boost/ptr_container/include
+)
+target_link_libraries(restricted-boost-ptr_container INTERFACE
+  contrib-libs-cxxsupp
+  yutil
+  restricted-boost-array
+  restricted-boost-assert
+  restricted-boost-circular_buffer
+  restricted-boost-config
+  restricted-boost-core
+  restricted-boost-iterator
+  restricted-boost-mpl
+  restricted-boost-range
+  restricted-boost-serialization
+  restricted-boost-smart_ptr
+  restricted-boost-static_assert
+  restricted-boost-type_traits
+  restricted-boost-unordered
+  restricted-boost-utility
+)