diff --git a/boost/boost/mpl/aux_/empty_impl.hpp b/boost/boost/mpl/aux_/empty_impl.hpp
new file mode 100644
index 0000000000..9a553a77fe
--- /dev/null
+++ b/boost/boost/mpl/aux_/empty_impl.hpp
@@ -0,0 +1,43 @@
+
+#ifndef BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: empty_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'empty_impl' or the primary 'empty' template
+
+template< typename Tag >
+struct empty_impl
+{
+    template< typename Sequence > struct apply
+        : is_same<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,empty_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED
diff --git a/boost/boost/mpl/aux_/insert_range_impl.hpp b/boost/boost/mpl/aux_/insert_range_impl.hpp
new file mode 100644
index 0000000000..c1a2f5434c
--- /dev/null
+++ b/boost/boost/mpl/aux_/insert_range_impl.hpp
@@ -0,0 +1,77 @@
+
+#ifndef BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+#define BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: insert_range_impl.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/clear.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/mpl/joint_view.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/iter_push_front.hpp>
+#include <boost/mpl/aux_/traits_lambda_spec.hpp>
+#include <boost/mpl/aux_/config/forwarding.hpp>
+
+#include <boost/type_traits/same_traits.hpp>
+
+namespace boost { namespace mpl {
+
+// default implementation; conrete sequences might override it by 
+// specializing either the 'insert_range_impl' or the primary 
+// 'insert_range' template
+
+
+template< typename Tag >
+struct insert_range_impl
+{
+    template<
+          typename Sequence
+        , typename Pos
+        , typename Range
+        >
+    struct apply
+#if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING)
+        : reverse_copy<
+              joint_view< 
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view< 
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , front_inserter< typename clear<Sequence>::type >
+            >
+    {
+#else
+    {
+        typedef typename reverse_copy<
+              joint_view< 
+                  iterator_range<typename begin<Sequence>::type,Pos>
+                , joint_view< 
+                      Range
+                    , iterator_range<Pos,typename end<Sequence>::type>
+                    >
+                >
+            , front_inserter< typename clear<Sequence>::type >
+            >::type type;
+#endif
+    };
+};
+
+BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_range_impl)
+
+}}
+
+#endif // BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED
diff --git a/boost/boost/mpl/aux_/iter_push_front.hpp b/boost/boost/mpl/aux_/iter_push_front.hpp
new file mode 100644
index 0000000000..2fa4f94ea8
--- /dev/null
+++ b/boost/boost/mpl/aux_/iter_push_front.hpp
@@ -0,0 +1,36 @@
+
+#ifndef BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+#define BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2002-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: iter_push_front.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/deref.hpp>
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename Sequence
+    , typename Iterator
+    >
+struct iter_push_front
+{
+    typedef typename push_front<
+          Sequence
+        , typename deref<Iterator>::type
+        >::type type;
+};
+
+}}}
+
+#endif // BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED
diff --git a/boost/boost/mpl/aux_/joint_iter.hpp b/boost/boost/mpl/aux_/joint_iter.hpp
new file mode 100644
index 0000000000..e2589dc19a
--- /dev/null
+++ b/boost/boost/mpl/aux_/joint_iter.hpp
@@ -0,0 +1,120 @@
+
+#ifndef BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+#define BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: joint_iter.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/next_prior.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/iterator_tags.hpp>
+#include <boost/mpl/aux_/lambda_spec.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#   include <boost/type_traits/is_same.hpp>
+#endif
+
+namespace boost { namespace mpl {
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+{
+    typedef Iterator1 base;
+    typedef forward_iterator_tag category;
+};
+
+template<
+      typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter<LastIterator1,LastIterator1,Iterator2>
+{
+    typedef Iterator2 base;
+    typedef forward_iterator_tag category;
+};
+
+
+template< typename I1, typename L1, typename I2 >
+struct deref< joint_iter<I1,L1,I2> >
+{
+    typedef typename joint_iter<I1,L1,I2>::base base_;
+    typedef typename deref<base_>::type type;
+};
+
+template< typename I1, typename L1, typename I2 >
+struct next< joint_iter<I1,L1,I2> >
+{
+    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
+};
+
+template< typename L1, typename I2 >
+struct next< joint_iter<L1,L1,I2> >
+{
+    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
+};
+
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter;
+
+template< bool > struct joint_iter_impl
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I1 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > next;
+        typedef typename deref<I1>::type type;
+    };
+};
+
+template<> struct joint_iter_impl<true>
+{
+    template< typename I1, typename L1, typename I2 > struct result_
+    {
+        typedef I2 base;
+        typedef forward_iterator_tag category;
+        typedef joint_iter< L1,L1,typename mpl::next<I2>::type > next;
+        typedef typename deref<I2>::type type;
+    };
+};
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+    : joint_iter_impl< is_same<Iterator1,LastIterator1>::value >
+        ::template result_<Iterator1,LastIterator1,Iterator2>
+{
+};
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, joint_iter)
+
+}}
+
+#endif // BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED
diff --git a/boost/boost/mpl/char.hpp b/boost/boost/mpl/char.hpp
new file mode 100644
index 0000000000..08828c247a
--- /dev/null
+++ b/boost/boost/mpl/char.hpp
@@ -0,0 +1,22 @@
+
+#ifndef BOOST_MPL_CHAR_HPP_INCLUDED
+#define BOOST_MPL_CHAR_HPP_INCLUDED
+
+// Copyright Eric Niebler 2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Source$
+// $Date: 2008-06-14 08:41:37 -0700 (Sat, 16 Jun 2008) $
+// $Revision: 24874 $
+
+#include <boost/mpl/char_fwd.hpp>
+
+#define AUX_WRAPPER_VALUE_TYPE char
+#include <boost/mpl/aux_/integral_wrapper.hpp>
+
+#endif // BOOST_MPL_CHAR_HPP_INCLUDED
diff --git a/boost/boost/mpl/char_fwd.hpp b/boost/boost/mpl/char_fwd.hpp
new file mode 100644
index 0000000000..442d0a1619
--- /dev/null
+++ b/boost/boost/mpl/char_fwd.hpp
@@ -0,0 +1,27 @@
+
+#ifndef BOOST_MPL_CHAR_FWD_HPP_INCLUDED
+#define BOOST_MPL_CHAR_FWD_HPP_INCLUDED
+
+// Copyright Eric Niebler 2008
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Source$
+// $Date: 2008-06-14 08:41:37 -0700 (Sat, 16 Jun 2008) $
+// $Revision: 24874 $
+
+#include <boost/mpl/aux_/adl_barrier.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
+
+template< BOOST_MPL_AUX_NTTP_DECL(char, N) > struct char_;
+
+BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
+BOOST_MPL_AUX_ADL_BARRIER_DECL(char_)
+
+#endif // BOOST_MPL_CHAR_FWD_HPP_INCLUDED
diff --git a/boost/boost/mpl/empty.hpp b/boost/boost/mpl/empty.hpp
new file mode 100644
index 0000000000..adb3c76c44
--- /dev/null
+++ b/boost/boost/mpl/empty.hpp
@@ -0,0 +1,39 @@
+
+#ifndef BOOST_MPL_EMPTY_HPP_INCLUDED
+#define BOOST_MPL_EMPTY_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: empty.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/empty_impl.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    >
+struct empty
+    : empty_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,empty,(Sequence))
+};
+
+BOOST_MPL_AUX_NA_SPEC(1, empty)
+
+}}
+
+#endif // BOOST_MPL_EMPTY_HPP_INCLUDED
diff --git a/boost/boost/mpl/insert_range.hpp b/boost/boost/mpl/insert_range.hpp
new file mode 100644
index 0000000000..9332b9e9fd
--- /dev/null
+++ b/boost/boost/mpl/insert_range.hpp
@@ -0,0 +1,41 @@
+
+#ifndef BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
+#define BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: insert_range.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/insert_range_fwd.hpp>
+#include <boost/mpl/sequence_tag.hpp>
+#include <boost/mpl/aux_/insert_range_impl.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost { namespace mpl {
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence)
+    , typename BOOST_MPL_AUX_NA_PARAM(Pos)
+    , typename BOOST_MPL_AUX_NA_PARAM(Range)
+    >
+struct insert_range
+    : insert_range_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,Pos,Range >
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert_range,(Sequence,Pos,Range))
+};
+
+BOOST_MPL_AUX_NA_SPEC(3, insert_range)
+
+}}
+
+#endif // BOOST_MPL_INSERT_RANGE_HPP_INCLUDED
diff --git a/boost/boost/mpl/insert_range_fwd.hpp b/boost/boost/mpl/insert_range_fwd.hpp
new file mode 100644
index 0000000000..256d2a2f80
--- /dev/null
+++ b/boost/boost/mpl/insert_range_fwd.hpp
@@ -0,0 +1,24 @@
+
+#ifndef BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
+#define BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: insert_range_fwd.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+namespace boost { namespace mpl {
+
+template< typename Tag > struct insert_range_impl;
+template< typename Sequence, typename Pos, typename Range > struct insert_range;
+
+}}
+
+#endif // BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED
diff --git a/boost/boost/mpl/joint_view.hpp b/boost/boost/mpl/joint_view.hpp
new file mode 100644
index 0000000000..dd8d91f646
--- /dev/null
+++ b/boost/boost/mpl/joint_view.hpp
@@ -0,0 +1,65 @@
+
+#ifndef BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
+#define BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: joint_view.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/aux_/joint_iter.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/size_fwd.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/aux_/na_spec.hpp>
+
+namespace boost { namespace mpl {
+
+namespace aux {
+struct joint_view_tag;
+}
+
+template<>
+struct size_impl< aux::joint_view_tag >
+{
+    template < typename JointView > struct apply
+      : plus<
+            size<typename JointView::sequence1_>
+          , size<typename JointView::sequence2_>
+          >
+    {};
+};
+
+template<
+      typename BOOST_MPL_AUX_NA_PARAM(Sequence1_)
+    , typename BOOST_MPL_AUX_NA_PARAM(Sequence2_)
+    >
+struct joint_view
+{
+    typedef typename mpl::begin<Sequence1_>::type   first1_;
+    typedef typename mpl::end<Sequence1_>::type     last1_;
+    typedef typename mpl::begin<Sequence2_>::type   first2_;
+    typedef typename mpl::end<Sequence2_>::type     last2_;
+
+    // agurt, 25/may/03: for the 'size_traits' implementation above
+    typedef Sequence1_ sequence1_;
+    typedef Sequence2_ sequence2_;
+
+    typedef joint_view type;
+    typedef aux::joint_view_tag tag;
+    typedef joint_iter<first1_,last1_,first2_>  begin;
+    typedef joint_iter<last1_,last1_,last2_>    end;
+};
+
+BOOST_MPL_AUX_NA_SPEC(2, joint_view)
+
+}}
+
+#endif // BOOST_MPL_JOINT_VIEW_HPP_INCLUDED
diff --git a/boost/boost/mpl/limits/string.hpp b/boost/boost/mpl/limits/string.hpp
new file mode 100644
index 0000000000..eb85aa389f
--- /dev/null
+++ b/boost/boost/mpl/limits/string.hpp
@@ -0,0 +1,21 @@
+
+#ifndef BOOST_MPL_LIMITS_STRING_HPP_INCLUDED
+#define BOOST_MPL_LIMITS_STRING_HPP_INCLUDED
+
+// Copyright Eric Niebler 2009
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: string.hpp 49239 2009-04-01 09:10:26Z eric_niebler $
+// $Date: 2009-04-01 02:10:26 -0700 (Wed, 1 Apr 2009) $
+// $Revision: 49239 $
+
+#if !defined(BOOST_MPL_LIMIT_STRING_SIZE)
+#   define BOOST_MPL_LIMIT_STRING_SIZE 32
+#endif
+
+#endif // BOOST_MPL_LIMITS_STRING_HPP_INCLUDED
diff --git a/boost/boost/mpl/string.hpp b/boost/boost/mpl/string.hpp
new file mode 100644
index 0000000000..c62d8ab9bc
--- /dev/null
+++ b/boost/boost/mpl/string.hpp
@@ -0,0 +1,607 @@
+
+#ifndef BOOST_MPL_STRING_HPP_INCLUDED
+#define BOOST_MPL_STRING_HPP_INCLUDED
+
+// Copyright Eric Niebler 2009
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: string.hpp 49239 2009-04-01 09:10:26Z eric_niebler $
+// $Date: 2009-04-01 02:10:26 -0700 (Wed, 1 Apr 2009) $
+// $Revision: 49239 $
+//
+// Thanks to:
+//   Dmitry Goncharov for porting this to the Sun compiler
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/detail/endian.hpp>
+#include <boost/mpl/limits/string.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/char.hpp>
+#include <boost/mpl/copy.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/joint_view.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/back_inserter.hpp>
+#include <boost/mpl/front_inserter.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/div.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+
+#include <iterator> // for bidirectional_iterator_tag
+#include <climits>
+
+namespace boost { namespace mpl
+{
+    #define BOOST_MPL_STRING_MAX_PARAMS                                                             \
+      BOOST_PP_DIV(BOOST_PP_ADD(BOOST_MPL_LIMIT_STRING_SIZE, 3), 4)
+
+    // Low-level bit-twiddling is done by macros. Any implementation-defined behavior of
+    // multi-character literals should be localized to these macros.
+
+    #define BOOST_MPL_MULTICHAR_LENGTH(c)                                                           \
+      (std::size_t)((c<CHAR_MIN) ? 4 : ((c>0xffffff)+(c>0xffff)+(c>0xff)+1))
+
+    #if defined(BOOST_LITTLE_ENDIAN) && defined(__SUNPRO_CC)
+
+        #define BOOST_MPL_MULTICHAR_AT(c,i)                                                         \
+          (char)(0xff&((unsigned)(c)>>(8*(std::size_t)(i))))
+
+        #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i)                                                  \
+          ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(unsigned)(c))
+
+        #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i)                                                 \
+          (((unsigned)(c)<<8)|(unsigned char)(i))
+
+        #define BOOST_MPL_MULTICHAR_POP_BACK(c)                                                     \
+          (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(unsigned)(c))
+
+        #define BOOST_MPL_MULTICHAR_POP_FRONT(c)                                                    \
+          ((unsigned)(c)>>8)
+
+    #else
+
+        #define BOOST_MPL_MULTICHAR_AT(c,i)                                                         \
+          (char)(0xff&((unsigned)(c)>>(8*(BOOST_MPL_MULTICHAR_LENGTH(c)-(std::size_t)(i)-1))))
+
+        #define BOOST_MPL_MULTICHAR_PUSH_BACK(c,i)                                                  \
+          (((unsigned)(c)<<8)|(unsigned char)(i))
+
+        #define BOOST_MPL_MULTICHAR_PUSH_FRONT(c,i)                                                 \
+          ((((unsigned char)(i))<<(BOOST_MPL_MULTICHAR_LENGTH(c)*8))|(unsigned)(c))
+
+        #define BOOST_MPL_MULTICHAR_POP_BACK(c)                                                     \
+          ((unsigned)(c)>>8)
+
+        #define BOOST_MPL_MULTICHAR_POP_FRONT(c)                                                    \
+          (((1<<((BOOST_MPL_MULTICHAR_LENGTH(c)-1)*8))-1)&(unsigned)(c))
+
+    #endif
+
+    struct string_tag;
+    struct string_iterator_tag;
+
+    template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_MPL_STRING_MAX_PARAMS, int C, 0)>
+    struct string;
+
+    template<typename Sequence, int I, int J>
+    struct string_iterator;
+
+    template<typename Sequence>
+    struct sequence_tag;
+
+    template<typename Tag>
+    struct size_impl;
+
+    template<>
+    struct size_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply;
+
+        #define M0(z, n, data)                                                                      \
+        + BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C,n))
+
+        #define M1(z, n, data)                                                                      \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)>                                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> >                                 \
+          : mpl::size_t<(0 BOOST_PP_REPEAT_ ## z(n, M0, ~))>                                        \
+        {};
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M1, ~)
+        #undef M0
+        #undef M1
+    };
+
+    template<>
+    struct size_impl<mpl::string_tag>::apply<mpl::string<> >
+      : mpl::size_t<0>
+    {};
+
+    template<typename Tag>
+    struct begin_impl;
+
+    template<>
+    struct begin_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply
+        {
+            typedef mpl::string_iterator<Sequence, 0, 0> type;
+        };
+    };
+
+    template<typename Tag>
+    struct end_impl;
+
+    template<>
+    struct end_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply;
+
+        #define M0(z,n,data)                                                                        \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)>                                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> >                                 \
+        {                                                                                           \
+            typedef mpl::string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, n, 0> type;  \
+        };
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~)
+        #undef M0
+    };
+
+    template<>
+    struct end_impl<mpl::string_tag>::apply<mpl::string<> >
+    {
+        typedef mpl::string_iterator<mpl::string<>, 0, 0> type;
+    };
+
+    template<typename Tag>
+    struct push_back_impl;
+
+    template<>
+    struct push_back_impl<mpl::string_tag>
+    {
+        template<typename Sequence, typename Value, bool B = (4==BOOST_MPL_MULTICHAR_LENGTH(Sequence::back_))>
+        struct apply
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (BOOST_MPL_LIMIT_STRING_SIZE != mpl::size<Sequence>::type::value)
+              , PUSH_BACK_FAILED_MPL_STRING_IS_FULL
+              , (Sequence)
+            );
+            // If the above assertion didn't fire, then the string is sparse.
+            // Repack the string and retry the push_back
+            typedef
+                typename mpl::push_back<
+                    typename mpl::copy<
+                        Sequence
+                      , mpl::back_inserter<mpl::string<> >
+                    >::type
+                  , Value
+                >::type
+            type;
+        };
+
+        template<typename Value>
+        struct apply<mpl::string<>, Value, false>
+        {
+            typedef mpl::string<(char)Value::value> type;
+        };
+
+        #define M0(z,n,data)                                                                        \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C), typename Value>                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, false>                    \
+        {                                                                                           \
+            typedef                                                                                 \
+                mpl::string<                                                                        \
+                    BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), C)                                   \
+                    BOOST_PP_COMMA_IF(BOOST_PP_DEC(n))                                              \
+                    ((unsigned)BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff)                            \
+                    ?BOOST_PP_CAT(C,BOOST_PP_DEC(n))                                                \
+                    :BOOST_MPL_MULTICHAR_PUSH_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(n)), Value::value)   \
+                  , ((unsigned)BOOST_PP_CAT(C,BOOST_PP_DEC(n))>0xffffff)                            \
+                    ?(char)Value::value                                                             \
+                    :0                                                                              \
+                >                                                                                   \
+            type;                                                                                   \
+        };
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~)
+        #undef M0
+
+        template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), typename Value>
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false>
+        {
+            typedef
+                mpl::string<
+                    BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS), C)
+                  , BOOST_MPL_MULTICHAR_PUSH_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS)), Value::value)
+                >
+            type;
+        };
+    };
+
+    template<typename Tag>
+    struct has_push_back_impl;
+
+    template<>
+    struct has_push_back_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply
+          : mpl::true_
+        {};
+    };
+
+    template<typename Tag>
+    struct pop_back_impl;
+
+    template<>
+    struct pop_back_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply;
+
+        #define M0(z,n,data)                                                                        \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)>                                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)> >                                 \
+        {                                                                                           \
+            BOOST_MPL_ASSERT_MSG((C0 != 0), POP_BACK_FAILED_MPL_STRING_IS_EMPTY, (mpl::string<>));  \
+            typedef                                                                                 \
+                mpl::string<                                                                        \
+                    BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_DEC(n), C)                                   \
+                    BOOST_PP_COMMA_IF(BOOST_PP_DEC(n))                                              \
+                    BOOST_MPL_MULTICHAR_POP_BACK(BOOST_PP_CAT(C,BOOST_PP_DEC(n)))                   \
+                >                                                                                   \
+            type;                                                                                   \
+        };
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_MPL_STRING_MAX_PARAMS), M0, ~)
+        #undef M0
+    };
+
+    template<typename Tag>
+    struct has_pop_back_impl;
+
+    template<>
+    struct has_pop_back_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply
+          : mpl::true_
+        {};
+    };
+
+    template<typename Tag>
+    struct push_front_impl;
+
+    template<>
+    struct push_front_impl<mpl::string_tag>
+    {
+        template<typename Sequence, typename Value, bool B = (4==BOOST_MPL_MULTICHAR_LENGTH(Sequence::front_))>
+        struct apply
+        {
+            BOOST_MPL_ASSERT_MSG(
+                (BOOST_MPL_LIMIT_STRING_SIZE != mpl::size<Sequence>::type::value)
+              , PUSH_FRONT_FAILED_MPL_STRING_IS_FULL
+              , (Sequence)
+            );
+            // If the above assertion didn't fire, then the string is sparse.
+            // Repack the string and retry the push_front.
+            typedef
+                typename mpl::push_front<
+                    typename mpl::reverse_copy<
+                        Sequence
+                      , mpl::front_inserter<string<> >
+                    >::type
+                  , Value
+                >::type
+            type;
+        };
+
+        #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+        template<typename Value>
+        struct apply<mpl::string<>, Value, false>
+        {
+            typedef mpl::string<(char)Value::value> type;
+        };
+        #endif
+
+        #define M0(z,n,data)                                                                        \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C), typename Value>                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, Value, true>                     \
+        {                                                                                           \
+            typedef                                                                                 \
+                mpl::string<                                                                        \
+                    (char)Value::value                                                              \
+                    BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, C)                                        \
+                >                                                                                   \
+            type;                                                                                   \
+        };
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~)
+        #undef M0
+
+        template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), typename Value>
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, Value, false>
+        {
+            typedef
+                mpl::string<
+                    BOOST_MPL_MULTICHAR_PUSH_FRONT(C0, Value::value)
+                  , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)
+                >
+            type0;
+
+            #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+            typedef
+                typename mpl::if_<
+                    mpl::empty<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> >
+                  , mpl::string<(char)Value::value>
+                  , type0
+                >::type
+            type;
+            #else
+            typedef type0 type;
+            #endif
+        };
+    };
+
+    template<typename Tag>
+    struct has_push_front_impl;
+
+    template<>
+    struct has_push_front_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply
+          : mpl::true_
+        {};
+    };
+
+    template<typename Tag>
+    struct pop_front_impl;
+
+    template<>
+    struct pop_front_impl<mpl::string_tag>
+    {
+        template<typename Sequence, bool B = (1==BOOST_MPL_MULTICHAR_LENGTH(Sequence::front_))>
+        struct apply;
+
+        #define M0(z,n,data)                                                                        \
+        template<BOOST_PP_ENUM_PARAMS_Z(z, n, int C)>                                               \
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS_Z(z, n, C)>, true>                            \
+        {                                                                                           \
+            BOOST_MPL_ASSERT_MSG((C0 != 0), POP_FRONT_FAILED_MPL_STRING_IS_EMPTY, (mpl::string<>)); \
+            typedef                                                                                 \
+                mpl::string<BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, n, C)>                                \
+            type;                                                                                   \
+        };
+
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_MPL_STRING_MAX_PARAMS, M0, ~)
+        #undef M0
+
+        template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)>
+        struct apply<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, false>
+        {
+            typedef
+                mpl::string<
+                    BOOST_MPL_MULTICHAR_POP_FRONT(C0)
+                  , BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)
+                >
+            type;
+        };
+    };
+
+    template<typename Tag>
+    struct has_pop_front_impl;
+
+    template<>
+    struct has_pop_front_impl<mpl::string_tag>
+    {
+        template<typename Sequence>
+        struct apply
+          : mpl::true_
+        {};
+    };
+
+    template<typename Tag>
+    struct insert_range_impl;
+
+    template<>
+    struct insert_range_impl<mpl::string_tag>
+    {
+        template<typename Sequence, typename Pos, typename Range>
+        struct apply
+          : mpl::copy<
+                mpl::joint_view<
+                    mpl::iterator_range<
+                        mpl::string_iterator<Sequence, 0, 0>
+                      , Pos
+                    >
+                  , mpl::joint_view<
+                        Range
+                      , mpl::iterator_range<
+                            Pos
+                          , typename mpl::end<Sequence>::type
+                        >
+                    >
+                >
+              , mpl::back_inserter<mpl::string<> >
+            >
+        {};
+    };
+
+    template<typename Tag>
+    struct insert_impl;
+
+    template<>
+    struct insert_impl<mpl::string_tag>
+    {
+        template<typename Sequence, typename Pos, typename Value>
+        struct apply
+          : mpl::insert_range<Sequence, Pos, mpl::string<(char)Value::value> >
+        {};
+    };
+
+    template<typename Tag>
+    struct erase_impl;
+
+    template<>
+    struct erase_impl<mpl::string_tag>
+    {
+        template<typename Sequence, typename First, typename Last>
+        struct apply
+          : mpl::copy<
+                mpl::joint_view<
+                    mpl::iterator_range<
+                        mpl::string_iterator<Sequence, 0, 0>
+                      , First
+                    >
+                  , mpl::iterator_range<
+                        typename mpl::if_na<Last, typename mpl::next<First>::type>::type
+                      , typename mpl::end<Sequence>::type
+                    >
+                >
+              , mpl::back_inserter<mpl::string<> >
+            >
+        {};
+    };
+
+    template<typename Tag>
+    struct clear_impl;
+
+    template<>
+    struct clear_impl<mpl::string_tag>
+    {
+        template<typename>
+        struct apply
+        {
+            typedef mpl::string<> type;
+        };
+    };
+
+    #define M0(z, n, data)                                                                            \
+    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C), int J>                         \
+    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, n, J>   \
+    {                                                                                                 \
+        enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == J + 1) };                   \
+        typedef mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> string;             \
+        typedef std::bidirectional_iterator_tag category;                                             \
+        typedef                                                                                       \
+            mpl::string_iterator<string, n + eomc_, eomc_ ? 0 : J + 1>                                \
+        next;                                                                                         \
+        typedef                                                                                       \
+            mpl::string_iterator<string, n, J - 1>                                                    \
+        prior;                                                                                        \
+        typedef mpl::char_<BOOST_MPL_MULTICHAR_AT(BOOST_PP_CAT(C, n), J)> type;                       \
+    };                                                                                                \
+    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)>                                \
+    struct string_iterator<mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)>, n, 0>   \
+    {                                                                                                 \
+        enum { eomc_ = (BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, n)) == 1) };                       \
+        typedef mpl::string<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, C)> string;             \
+        typedef std::bidirectional_iterator_tag category;                                             \
+        typedef                                                                                       \
+            mpl::string_iterator<string, n + eomc_, !eomc_>                                           \
+        next;                                                                                         \
+        typedef                                                                                       \
+            mpl::string_iterator<                                                                     \
+                string                                                                                \
+              , n - 1                                                                                 \
+              , BOOST_MPL_MULTICHAR_LENGTH(BOOST_PP_CAT(C, BOOST_PP_DEC(n))) - 1                      \
+            >                                                                                         \
+        prior;                                                                                        \
+        typedef mpl::char_<BOOST_MPL_MULTICHAR_AT(BOOST_PP_CAT(C, n), 0)> type;                       \
+    };
+
+    BOOST_PP_REPEAT(BOOST_MPL_STRING_MAX_PARAMS, M0, ~)
+    #undef M0
+
+    template<BOOST_PP_ENUM_PARAMS(BOOST_MPL_STRING_MAX_PARAMS, int C)>
+    struct string
+    {
+        /// INTERNAL ONLY
+        enum
+        {
+            front_  = C0
+          , back_   = BOOST_PP_CAT(C, BOOST_PP_DEC(BOOST_MPL_STRING_MAX_PARAMS))
+        };
+
+        typedef char        value_type;
+        typedef string      type;
+        typedef string_tag  tag;
+    };
+
+    namespace aux_
+    {
+        template<typename It, typename End>
+        struct next_unless
+          : mpl::next<It>
+        {};
+
+        template<typename End>
+        struct next_unless<End, End>
+        {
+            typedef End type;
+        };
+
+        template<typename It, typename End>
+        struct deref_unless
+          : mpl::deref<It>
+        {};
+
+        template<typename End>
+        struct deref_unless<End, End>
+        {
+            typedef mpl::char_<'\0'> type;
+        };
+    }
+
+    template<typename Sequence>
+    struct c_str
+    {
+        typedef typename mpl::end<Sequence>::type iend;
+        typedef typename mpl::begin<Sequence>::type i0;
+        #define M0(z, n, data)                                                                      \
+        typedef                                                                                     \
+            typename mpl::aux_::next_unless<BOOST_PP_CAT(i, n), iend>::type                         \
+        BOOST_PP_CAT(i, BOOST_PP_INC(n));
+        BOOST_PP_REPEAT(BOOST_MPL_LIMIT_STRING_SIZE, M0, ~)
+        #undef M0
+
+        typedef c_str type;
+        static typename Sequence::value_type const value[BOOST_MPL_LIMIT_STRING_SIZE+1];
+    };
+
+    template<typename Sequence>
+    typename Sequence::value_type const c_str<Sequence>::value[BOOST_MPL_LIMIT_STRING_SIZE+1] =
+    {
+        #define M0(z, n, data)                                                                      \
+        mpl::aux_::deref_unless<BOOST_PP_CAT(i, n), iend>::type::value,
+        BOOST_PP_REPEAT(BOOST_MPL_LIMIT_STRING_SIZE, M0, ~)
+        #undef M0
+        '\0'
+    };
+
+}} // namespace boost
+
+#endif // BOOST_MPL_STRING_HPP_INCLUDED
diff --git a/boost/boost/preprocessor/arithmetic/div.hpp b/boost/boost/preprocessor/arithmetic/div.hpp
new file mode 100644
index 0000000000..277596cea9
--- /dev/null
+++ b/boost/boost/preprocessor/arithmetic/div.hpp
@@ -0,0 +1,39 @@
+# /* Copyright (C) 2001
+#  * Housemarque Oy
+#  * http://www.housemarque.com
+#  *
+#  * Distributed under the Boost Software License, Version 1.0. (See
+#  * accompanying file LICENSE_1_0.txt or copy at
+#  * http://www.boost.org/LICENSE_1_0.txt)
+#  */
+#
+# /* Revised by Paul Mensonides (2002) */
+#
+# /* See http://www.boost.org for most recent version. */
+#
+# ifndef BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP
+# define BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP
+#
+# include <boost/preprocessor/arithmetic/detail/div_base.hpp>
+# include <boost/preprocessor/config/config.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+#
+# /* BOOST_PP_DIV */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+#    define BOOST_PP_DIV(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y))
+# else
+#    define BOOST_PP_DIV(x, y) BOOST_PP_DIV_I(x, y)
+#    define BOOST_PP_DIV_I(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y))
+# endif
+#
+# /* BOOST_PP_DIV_D */
+#
+# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
+#    define BOOST_PP_DIV_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y))
+# else
+#    define BOOST_PP_DIV_D(d, x, y) BOOST_PP_DIV_D_I(d, x, y)
+#    define BOOST_PP_DIV_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y))
+# endif
+#
+# endif
diff --git a/boost/boost/type_traits/same_traits.hpp b/boost/boost/type_traits/same_traits.hpp
new file mode 100644
index 0000000000..dab7dac783
--- /dev/null
+++ b/boost/boost/type_traits/same_traits.hpp
@@ -0,0 +1,15 @@
+//  (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000.
+//  Use, modification and distribution are 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).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+//
+//  defines is_same:
+
+#ifndef BOOST_TT_SAME_TRAITS_HPP_INCLUDED
+#define BOOST_TT_SAME_TRAITS_HPP_INCLUDED
+
+#include <boost/type_traits/is_same.hpp>
+
+#endif  // BOOST_TT_SAME_TRAITS_HPP_INCLUDED
diff --git a/boost/extract.sh b/boost/extract.sh
index 80aca393c8..dbe280b07d 100755
--- a/boost/extract.sh
+++ b/boost/extract.sh
@@ -40,6 +40,10 @@ bcp --boost=$1 \
 	boost/signals/trackable.hpp \
 	boost/tokenizer.hpp \
 	boost/tuple/tuple.hpp \
+    boost/mpl/string.hpp \
+    boost/mpl/fold.hpp \
+    boost/mpl/size_t.hpp \
+    boost/functional/hash.hpp \
 	\
 	needed
 
@@ -52,4 +56,12 @@ cp -vR needed/libs .
 
 rm -rf needed
 
+# found by bcp but not needed by us
+rm -rf libs/config
+rm -rf libs/smart_ptr
+rm -rf libs/signals/build
+rm -rf libs/regex/build
+rm -rf libs/regex/test
+
+