From fa06f3acc21a2035e115ef5d47adfd08c9494ff6 Mon Sep 17 00:00:00 2001
From: =?utf8?q?Lars=20Gullik=20Bj=C3=B8nnes?= <larsbj@gullik.org>
Date: Tue, 18 Jun 2002 15:39:27 +0000
Subject: [PATCH] update

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@4415 a592a061-630c-0410-9148-cb99ea01b6c8
---
 boost/ChangeLog                               |   4 +
 boost/boost/any.hpp                           |   4 +-
 boost/boost/array_traits.hpp                  |   2 +-
 boost/boost/bind.hpp                          |  82 ++-
 boost/boost/config/platform/macos.hpp         |   2 +-
 boost/boost/cregex.hpp                        |   2 +-
 boost/boost/detail/iterator.hpp               |  12 +-
 boost/boost/detail/limits.hpp                 |  25 +-
 boost/boost/function/function_base.hpp        |   2 -
 boost/boost/functional.hpp                    |   2 +-
 boost/boost/integer_traits.hpp                |   2 +-
 boost/boost/preprocessor.hpp                  |   2 -
 boost/boost/preprocessor/arithmetic/add.hpp   |  18 +-
 boost/boost/preprocessor/arithmetic/div.hpp   |  18 +-
 boost/boost/preprocessor/arithmetic/mod.hpp   |  14 +-
 boost/boost/preprocessor/arithmetic/mul.hpp   |  18 +-
 boost/boost/preprocessor/arithmetic/sub.hpp   |  18 +-
 boost/boost/preprocessor/assert_msg.hpp       |   3 -
 boost/boost/preprocessor/cat.hpp              |   3 -
 boost/boost/preprocessor/comma.hpp            |   3 -
 boost/boost/preprocessor/comma_if.hpp         |   3 -
 boost/boost/preprocessor/comparison/equal.hpp |  10 +-
 .../boost/preprocessor/comparison/greater.hpp |  10 +-
 .../preprocessor/comparison/greater_equal.hpp |  10 +-
 boost/boost/preprocessor/comparison/less.hpp  |  10 +-
 .../preprocessor/comparison/less_equal.hpp    |  10 +-
 .../preprocessor/comparison/not_equal.hpp     |  10 +-
 boost/boost/preprocessor/dec.hpp              |   8 +-
 boost/boost/preprocessor/empty.hpp            |   3 -
 boost/boost/preprocessor/enum.hpp             |  62 +-
 boost/boost/preprocessor/enum_params.hpp      |   3 -
 .../enum_params_with_a_default.hpp            |   9 +-
 .../enum_params_with_defaults.hpp             |   9 +-
 boost/boost/preprocessor/enum_shifted.hpp     |   6 +-
 .../preprocessor/enum_shifted_params.hpp      |   3 -
 boost/boost/preprocessor/expr_if.hpp          |   9 +-
 boost/boost/preprocessor/for.hpp              |  10 +-
 boost/boost/preprocessor/identity.hpp         |   3 -
 boost/boost/preprocessor/if.hpp               |  12 +-
 boost/boost/preprocessor/inc.hpp              |   8 +-
 boost/boost/preprocessor/limits.hpp           |  17 +-
 boost/boost/preprocessor/list.hpp             |  15 +-
 boost/boost/preprocessor/list/adt.hpp         |  29 +-
 boost/boost/preprocessor/list/append.hpp      |   9 +-
 boost/boost/preprocessor/list/at.hpp          |   7 +-
 boost/boost/preprocessor/list/cat.hpp         |  11 +-
 boost/boost/preprocessor/list/enum.hpp        |   2 +-
 boost/boost/preprocessor/list/filter.hpp      |  17 +-
 boost/boost/preprocessor/list/first_n.hpp     |  18 +-
 boost/boost/preprocessor/list/fold_left.hpp   |  56 +-
 .../boost/preprocessor/list/fold_left_2nd.hpp |  22 +-
 boost/boost/preprocessor/list/fold_right.hpp  |  46 +-
 .../preprocessor/list/fold_right_2nd.hpp      |  19 +-
 boost/boost/preprocessor/list/for_each.hpp    |  10 +-
 boost/boost/preprocessor/list/for_each_i.hpp  |  15 +-
 .../preprocessor/list/for_each_product.hpp    |  30 +-
 boost/boost/preprocessor/list/rest_n.hpp      |  17 +-
 boost/boost/preprocessor/list/reverse.hpp     |   9 +-
 boost/boost/preprocessor/list/size.hpp        |   9 +-
 boost/boost/preprocessor/list/to_tuple.hpp    |   7 +-
 boost/boost/preprocessor/list/transform.hpp   |  17 +-
 boost/boost/preprocessor/logical/and.hpp      |   3 -
 boost/boost/preprocessor/logical/bool.hpp     |   8 +-
 boost/boost/preprocessor/logical/nor.hpp      |  16 +-
 boost/boost/preprocessor/logical/not.hpp      |   3 -
 boost/boost/preprocessor/logical/or.hpp       |   3 -
 boost/boost/preprocessor/logical/xor.hpp      |   3 -
 boost/boost/preprocessor/max.hpp              |  10 +-
 boost/boost/preprocessor/min.hpp              |  10 +-
 boost/boost/preprocessor/repeat.hpp           | 576 +++++++++++++-----
 boost/boost/preprocessor/repeat_2nd.hpp       | 144 +----
 boost/boost/preprocessor/repeat_3rd.hpp       | 140 +----
 boost/boost/preprocessor/repeat_from_to.hpp   |  71 ++-
 .../boost/preprocessor/repeat_from_to_2nd.hpp |  13 +-
 .../boost/preprocessor/repeat_from_to_3rd.hpp |  13 +-
 boost/boost/preprocessor/stringize.hpp        |   3 -
 boost/boost/preprocessor/tuple/eat.hpp        |   5 +-
 boost/boost/preprocessor/tuple/elem.hpp       | 179 +-----
 boost/boost/preprocessor/while.hpp            |  16 +-
 boost/boost/property_map.hpp                  |   2 +-
 boost/boost/regex.hpp                         |   2 +-
 boost/boost/regex/detail/fileiter.hpp         |   2 +-
 boost/boost/regex/detail/instances.hpp        |   4 +
 boost/boost/regex/detail/regex_compile.hpp    |  19 +-
 boost/boost/regex/detail/regex_cstring.hpp    |   2 +-
 boost/boost/regex/detail/regex_format.hpp     |   2 +-
 boost/boost/regex/detail/regex_kmp.hpp        |  17 +-
 boost/boost/regex/detail/regex_match.hpp      |  32 +-
 boost/boost/regex/detail/regex_raw_buffer.hpp |   2 +-
 boost/boost/regex/detail/regex_split.hpp      |   2 +-
 boost/boost/regex/detail/regex_stack.hpp      |   2 +-
 boost/boost/regex/detail/regex_synch.hpp      |   2 +-
 boost/boost/regex/pattern_except.hpp          |   2 +-
 boost/boost/regex/regex_traits.hpp            |   6 +-
 boost/boost/signal.hpp                        |  75 +--
 boost/boost/signals/connection.hpp            | 127 ++--
 boost/boost/signals/detail/signal_base.hpp    |   6 +-
 boost/boost/signals/detail/signals_common.hpp |   8 +-
 .../signals/detail/slot_call_iterator.hpp     |   4 +-
 boost/boost/signals/signal_template.hpp       |  50 +-
 boost/boost/signals/slot.hpp                  |  24 +-
 boost/boost/signals/trackable.hpp             |   6 +-
 boost/boost/tuple/tuple_comparison.hpp        |   2 +-
 boost/boost/type_traits/array_traits.hpp      |   1 +
 boost/libs/regex/src/c_regex_traits.cpp       |  25 +-
 boost/libs/regex/src/cpp_regex_traits.cpp     |   7 +-
 boost/libs/regex/src/w32_regex_traits.cpp     |  16 +-
 boost/libs/signals/src/connection.cpp         |   9 +-
 boost/libs/signals/src/signal_base.cpp        |  24 +-
 boost/libs/signals/src/slot.cpp               |   8 +-
 boost/libs/signals/src/trackable.cpp          |   8 +-
 111 files changed, 1194 insertions(+), 1346 deletions(-)

diff --git a/boost/ChangeLog b/boost/ChangeLog
index 4129834984..013bcb3cc9 100644
--- a/boost/ChangeLog
+++ b/boost/ChangeLog
@@ -1,3 +1,7 @@
+2002-06-16  Lars Gullik Bjønnes  <larsbj@birdstep.com>
+
+	* update boost. (prev commit lost).
+
 2002-06-12  Angus Leeming  <leeming@lyx.org>
 
 	* boost/signals/connection.hpp:
diff --git a/boost/boost/any.hpp b/boost/boost/any.hpp
index bda7f2efb1..5587aa6e41 100644
--- a/boost/boost/any.hpp
+++ b/boost/boost/any.hpp
@@ -82,7 +82,7 @@ namespace boost
         class placeholder
         {
         public: // structors
-
+    
             virtual ~placeholder()
             {
             }
@@ -92,7 +92,7 @@ namespace boost
             virtual const std::type_info & type() const = 0;
 
             virtual placeholder * clone() const = 0;
-
+    
         };
 
         template<typename ValueType>
diff --git a/boost/boost/array_traits.hpp b/boost/boost/array_traits.hpp
index 81971b99b3..0ea66d405e 100644
--- a/boost/boost/array_traits.hpp
+++ b/boost/boost/array_traits.hpp
@@ -13,7 +13,7 @@
 
 // Author: Dietmar Kuehl dietmar.kuehl@claas-solutions.de 
 // Title:  STL container support, including support for built-in arrays
-// Version: $Id: array_traits.hpp,v 1.2 2002/05/24 12:19:51 larsbj Exp $
+// Version: $Id: array_traits.hpp,v 1.3 2002/06/18 15:39:24 larsbj Exp $
 
 // Dec 4, 2000  Added some more typedefs to array_traits including
 //              an iterator type to supersede iter_type. -J.Siek
diff --git a/boost/boost/bind.hpp b/boost/boost/bind.hpp
index ddbabbd75c..5a3ffbfd43 100644
--- a/boost/boost/bind.hpp
+++ b/boost/boost/bind.hpp
@@ -59,6 +59,11 @@ template<class F> struct result_traits<unspecified, F>
     typedef typename F::result_type type;
 };
 
+template<class F> struct result_traits< unspecified, reference_wrapper<F> >
+{
+    typedef typename F::result_type type;
+};
+
 #endif
 
 // bind_t forward declaration for listN
@@ -85,6 +90,23 @@ private:
 
 template<class T> class type {};
 
+// unwrap
+
+template<class F> inline F & unwrap(F & f, long)
+{
+    return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> & f, int)
+{
+    return f;
+}
+
+template<class F> inline F & unwrap(reference_wrapper<F> const & f, int)
+{
+    return f;
+}
+
 // listN
 
 #ifdef BOOST_NO_VOID_RETURNS
@@ -120,7 +142,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A &) const
     {
-        return f();
+        return unwrap(f, 0)();
     }
 
     template<class V> void accept(V &) const
@@ -160,7 +182,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_]);
+        return unwrap(f, 0)(a[a1_]);
     }
 
     template<class V> void accept(V & v) const
@@ -208,7 +230,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_]);
+        return unwrap(f, 0)(a[a1_], a[a2_]);
     }
 
     template<class V> void accept(V & v) const
@@ -260,7 +282,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
     }
 
     template<class V> void accept(V & v) const
@@ -316,7 +338,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
     }
 
     template<class V> void accept(V & v) const
@@ -376,7 +398,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
     }
 
     template<class V> void accept(V & v) const
@@ -440,7 +462,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
     }
 
     template<class V> void accept(V & v) const
@@ -508,7 +530,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
     }
 
     template<class V> void accept(V & v) const
@@ -580,7 +602,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
     }
 
     template<class V> void accept(V & v) const
@@ -656,7 +678,7 @@ public:
 
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
-        return f(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
     }
 
     template<class V> void accept(V & v) const
@@ -703,7 +725,7 @@ template <class R> struct evaluator0
     template<class L, class F, class A>
     static R eval(L const&, F f, A &)
     {
-        return f();
+        return unwrap(f, 0)();
     }
 };
 
@@ -712,7 +734,7 @@ template <> struct evaluator0<void>
     template<class L, class F, class A>
     static void eval(L const&, F f, A &)
     {
-        f();
+        unwrap(f, 0)();
     }
 };
 
@@ -721,7 +743,7 @@ template <class R> struct evaluator1
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_]);
+        return unwrap(f, 0)(a[l.a1_]);
     }
 };
 
@@ -730,7 +752,7 @@ template <> struct evaluator1<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_]);
+        unwrap(f, 0)(a[l.a1_]);
     }
 };
 
@@ -739,7 +761,7 @@ template <class R> struct evaluator2
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
 };
 
@@ -748,7 +770,7 @@ template <> struct evaluator2<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
 };
 
@@ -757,7 +779,7 @@ template <class R> struct evaluator3
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
 };
 
@@ -766,7 +788,7 @@ template <> struct evaluator3<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
 };
 
@@ -775,7 +797,7 @@ template <class R> struct evaluator4
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
 };
 
@@ -784,7 +806,7 @@ template <> struct evaluator4<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
 };
 
@@ -793,7 +815,7 @@ template <class R> struct evaluator5
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
 };
 
@@ -802,7 +824,7 @@ template <> struct evaluator5<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
 };
 
@@ -811,7 +833,7 @@ template <class R> struct evaluator6
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
 };
 
@@ -820,7 +842,7 @@ template <> struct evaluator6<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
 };
 
@@ -829,7 +851,7 @@ template <class R> struct evaluator7
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
     }
 };
 
@@ -838,7 +860,7 @@ template <> struct evaluator7<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
     }
 };
 
@@ -847,7 +869,7 @@ template <class R> struct evaluator8
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
     }
 };
 
@@ -856,7 +878,7 @@ template <> struct evaluator8<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
     }
 };
 
@@ -865,7 +887,7 @@ template <class R> struct evaluator9
     template<class L, class F, class A>
     static R eval(L const& l, F f, A & a)
     {
-        return f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+        return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
     }
 };
 
@@ -874,7 +896,7 @@ template <> struct evaluator9<void>
     template<class L, class F, class A>
     static void eval(L const& l, F f, A & a)
     {
-        f(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
+        unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
     }
 };
 
diff --git a/boost/boost/config/platform/macos.hpp b/boost/boost/config/platform/macos.hpp
index 51d030121e..424027c4f4 100644
--- a/boost/boost/config/platform/macos.hpp
+++ b/boost/boost/config/platform/macos.hpp
@@ -10,7 +10,7 @@
 #define BOOST_PLATFORM "Mac OS"
 
 // If __MACH__, we're using the BSD standard C library, not the MSL:
-#if defined(__MACH__)
+#if __MACH__
 
 #  define BOOST_NO_CTYPE_FUNCTIONS
 #  define BOOST_NO_CWCHAR
diff --git a/boost/boost/cregex.hpp b/boost/boost/cregex.hpp
index cd628559c2..5c11e09bb1 100644
--- a/boost/boost/cregex.hpp
+++ b/boost/boost/cregex.hpp
@@ -27,7 +27,7 @@
 #include <boost/regex/config.hpp>
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 /* include these defs only for POSIX compatablity */
diff --git a/boost/boost/detail/iterator.hpp b/boost/boost/detail/iterator.hpp
index c485a4d685..9833146f47 100644
--- a/boost/boost/detail/iterator.hpp
+++ b/boost/boost/detail/iterator.hpp
@@ -62,14 +62,10 @@
 # include <iterator>
 # include <cstddef>
 
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
 #  include <xtree>
 #  include <deque>
 #  include <list>
-#  if 0 && defined(__ICL) // Re-enable this to pick up the Intel fixes where they left off
-#   include <iosfwd>
-#   include <memory>
-#  endif
 # endif
 
 
@@ -110,7 +106,7 @@ template <> struct iterator_traits_select<true>
         typedef std::ptrdiff_t difference_type;
         typedef std::random_access_iterator_tag iterator_category;
         typedef Ptr pointer;
-#ifdef BOOST_MSVC
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
 // Keeps MSVC happy under certain circumstances. It seems class template default
 // arguments are partly instantiated even when not used when the class template
 // is the return type of a function template.
@@ -183,7 +179,7 @@ struct bad_output_iterator_select<false>
 };
 # endif
 
-# if defined(BOOST_MSVC_STD_ITERATOR)
+# if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
 
 // We'll sort iterator types into one of these classifications, from which we
 // can determine the difference_type, pointer, reference, and value_type
@@ -291,7 +287,7 @@ template <> struct iterator_traits_select<false>
     template <class Iterator>
     struct traits
     {
-#   if defined(BOOST_MSVC_STD_ITERATOR)
+#   if defined(BOOST_MSVC_STD_ITERATOR) && !defined(__SGI_STL_PORT)
         typedef msvc_traits_select<(
             msvc_iterator_classification<Iterator>::value
         )>::template traits_<Iterator> inner_traits;
diff --git a/boost/boost/detail/limits.hpp b/boost/boost/detail/limits.hpp
index af0f78df91..2249e84a2d 100644
--- a/boost/boost/detail/limits.hpp
+++ b/boost/boost/detail/limits.hpp
@@ -159,7 +159,7 @@ template <class _Int,
           _Int __imin,
           _Int __imax,
           int __idigits = -1>
-class _Integer_limits : public _Numeric_limits_base<_Int>
+class _Integer_limits : public _Numeric_limits_base<_Int> 
 {
 public:
   BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true);
@@ -170,9 +170,9 @@ public:
   BOOST_STL_DECLARE_LIMITS_MEMBER(int,
                               digits,
                               (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT)
-                                                   - (__imin == 0 ? 0 : 1)
+                                                   - (__imin == 0 ? 0 : 1) 
                                               : __idigits);
-  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000);
+  BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); 
                                 // log 2 = 0.301029995664...
 
   BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed,  __imin != 0);
@@ -192,7 +192,7 @@ public:
     // sizeof(long double) == 16
     const unsigned int _S_word[4] = { Word, 0, 0, 0 };
     return *reinterpret_cast<const Number*>(&_S_word);
-  }
+  } 
 };
 
 #else
@@ -205,7 +205,7 @@ public:
     return *reinterpret_cast<const Number*>(
         reinterpret_cast<const char *>(&_S_word)+16-
                 (sizeof(Number) == 12 ? 10 : sizeof(Number)));
-  }
+  } 
 };
 
 #endif
@@ -244,7 +244,7 @@ public:
                               denorm_indeterminate);
   BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss,   false);
 
-
+ 
   static __number infinity() throw() {
     return float_helper<__number, __InfinityWord>::get_word();
   }
@@ -267,7 +267,7 @@ public:
 
 // The unspecialized class.
 
-template<class T>
+template<class T> 
 class numeric_limits : public _Numeric_limits_base<T> {};
 
 // Specializations for all built-in integral types.
@@ -356,7 +356,7 @@ class numeric_limits<unsigned long>
 
 #if !defined(LONGLONG_MIN)
 # define LONGLONG_MIN (-LONGLONG_MAX - 1)
-#endif
+#endif 
 
 template<>
 class numeric_limits<long long>
@@ -373,7 +373,7 @@ class numeric_limits<unsigned long long>
 // Specializations for all built-in floating-point type.
 
 template<> class numeric_limits<float>
-  : public _Floating_limits<float,
+  : public _Floating_limits<float, 
                             FLT_MANT_DIG,   // Binary digits of precision
                             FLT_DIG,        // Decimal digits of precision
                             FLT_MIN_EXP,    // Minimum exponent
@@ -401,7 +401,7 @@ public:
 };
 
 template<> class numeric_limits<double>
-  : public _Floating_limits<double,
+  : public _Floating_limits<double, 
                             DBL_MANT_DIG,   // Binary digits of precision
                             DBL_DIG,        // Decimal digits of precision
                             DBL_MIN_EXP,    // Minimum exponent
@@ -429,7 +429,7 @@ public:
 };
 
 template<> class numeric_limits<long double>
-  : public _Floating_limits<long double,
+  : public _Floating_limits<long double, 
                             LDBL_MANT_DIG,  // Binary digits of precision
                             LDBL_DIG,       // Decimal digits of precision
                             LDBL_MIN_EXP,   // Minimum exponent
@@ -463,3 +463,6 @@ public:
 // Local Variables:
 // mode:C++
 // End:
+
+
+
diff --git a/boost/boost/function/function_base.hpp b/boost/boost/function/function_base.hpp
index 70b4eefde3..46d8863e07 100644
--- a/boost/boost/function/function_base.hpp
+++ b/boost/boost/function/function_base.hpp
@@ -34,8 +34,6 @@
 namespace boost {
   namespace detail {
     namespace function {
-      template<bool> struct truth {};
-
       /*
        * The ct_if implementation is temporary code. When a Boost metaprogramming
        * library is introduced, Boost.Function will use it instead. 
diff --git a/boost/boost/functional.hpp b/boost/boost/functional.hpp
index 6e7efbea78..b433924479 100644
--- a/boost/boost/functional.hpp
+++ b/boost/boost/functional.hpp
@@ -14,7 +14,7 @@
 // purpose.  It is provided "as is" without express or implied
 // warranty.
 // ------------------------------------------------------------------------------
-// $Id: functional.hpp,v 1.3 2000/11/22 09:04:28 mark_rodgers Exp $
+// $Id: functional.hpp,v 1.3 2002/06/16 13:12:16 lyx Exp $
 // ------------------------------------------------------------------------------
 
 #ifndef BOOST_FUNCTIONAL_HPP
diff --git a/boost/boost/integer_traits.hpp b/boost/boost/integer_traits.hpp
index 7fdeb285c3..8c77a780aa 100644
--- a/boost/boost/integer_traits.hpp
+++ b/boost/boost/integer_traits.hpp
@@ -10,7 +10,7 @@
  * software for any purpose. It is provided "as is" without express or
  * implied warranty.
  *
- * $Id: integer_traits.hpp,v 1.18 2002/01/23 19:56:07 dgregor Exp $
+ * $Id: integer_traits.hpp,v 1.3 2002/06/16 13:12:16 lyx Exp $
  *
  * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
  */
diff --git a/boost/boost/preprocessor.hpp b/boost/boost/preprocessor.hpp
index cc09742256..970ba30c30 100644
--- a/boost/boost/preprocessor.hpp
+++ b/boost/boost/preprocessor.hpp
@@ -30,7 +30,5 @@
 #include <boost/preprocessor/max.hpp>
 #include <boost/preprocessor/min.hpp>
 #include <boost/preprocessor/repeat_from_to.hpp>
-#include <boost/preprocessor/repeat_from_to_2nd.hpp>
-#include <boost/preprocessor/repeat_from_to_3rd.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #endif
diff --git a/boost/boost/preprocessor/arithmetic/add.hpp b/boost/boost/preprocessor/arithmetic/add.hpp
index fe8b536124..d7d2c24b45 100644
--- a/boost/boost/preprocessor/arithmetic/add.hpp
+++ b/boost/boost/preprocessor/arithmetic/add.hpp
@@ -26,11 +26,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_ADD(4,3)</code> expands to <code>7</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -38,16 +33,9 @@ single token).</p>
 */
 #define BOOST_PP_ADD(X,Y) BOOST_PP_ADD_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_ADD_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_ADD_C,BOOST_PP_ADD_F,(X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_ADD_C(D,P) BOOST_PP_TUPLE_ELEM(2,1,P)
-#  define BOOST_PP_ADD_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2,0,P)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,P)))
-#else
-#  define BOOST_PP_ADD_C(D,P) BOOST_PP_TUPLE2_ELEM1 P
-#  define BOOST_PP_ADD_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE2_ELEM0 P),BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 P))
-#endif
 
-/* <p>Obsolete. Use BOOST_PP_ADD().</p> */
-#define BOOST_PREPROCESSOR_ADD(X,Y) BOOST_PP_ADD(X,Y)
+#define BOOST_PP_ADD_C(D,RC) BOOST_PP_TUPLE_ELEM(2,1,RC)
+#define BOOST_PP_ADD_F(D,RC) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2,0,RC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,RC)))
 #endif
diff --git a/boost/boost/preprocessor/arithmetic/div.hpp b/boost/boost/preprocessor/arithmetic/div.hpp
index 8f4166244d..0074c56823 100644
--- a/boost/boost/preprocessor/arithmetic/div.hpp
+++ b/boost/boost/preprocessor/arithmetic/div.hpp
@@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_DIV(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -36,16 +31,9 @@ single token).</p>
 */
 #define BOOST_PP_DIV(X,Y) BOOST_PP_DIV_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_DIV_D(D,X,Y) BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_DIV_C,BOOST_PP_DIV_F,(0,X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_DIV_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(3,2,P),BOOST_PP_TUPLE_ELEM(3,1,P))
-#  define BOOST_PP_DIV_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3,0,P)),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_TUPLE_ELEM(3,2,P)),BOOST_PP_TUPLE_ELEM(3,2,P))
-#else
-#  define BOOST_PP_DIV_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE3_ELEM2 P,BOOST_PP_TUPLE3_ELEM1 P)
-#  define BOOST_PP_DIV_F(D,P) (BOOST_PP_INC(BOOST_PP_TUPLE3_ELEM0 P),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_TUPLE3_ELEM2 P),BOOST_PP_TUPLE3_ELEM2 P)
-#endif
 
-/* <p>Obsolete. Use BOOST_PP_DIV().</p> */
-#define BOOST_PREPROCESSOR_DIV(X,Y) BOOST_PP_DIV(X,Y)
+#define BOOST_PP_DIV_C(D,RCY) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(3,2,RCY),BOOST_PP_TUPLE_ELEM(3,1,RCY))
+#define BOOST_PP_DIV_F(D,RCY) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3,0,RCY)),BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(3,1,RCY),BOOST_PP_TUPLE_ELEM(3,2,RCY)),BOOST_PP_TUPLE_ELEM(3,2,RCY))
 #endif
diff --git a/boost/boost/preprocessor/arithmetic/mod.hpp b/boost/boost/preprocessor/arithmetic/mod.hpp
index 0cc043db47..268e220710 100644
--- a/boost/boost/preprocessor/arithmetic/mod.hpp
+++ b/boost/boost/preprocessor/arithmetic/mod.hpp
@@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_MOD(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -35,11 +30,8 @@ single token).</p>
 */
 #define BOOST_PP_MOD(X,Y) BOOST_PP_MOD_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_MOD_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_MOD_C,BOOST_PP_MOD_F,(X,Y)))
-#define BOOST_PP_MOD_C(D,P) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE2_ELEM1 P,BOOST_PP_TUPLE2_ELEM0 P)
-#define BOOST_PP_MOD_F(D,P) (BOOST_PP_SUB_D(D,BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM1 P),BOOST_PP_TUPLE2_ELEM1 P)
-
-/* <p>Obsolete. Use BOOST_PP_MOD().</p> */
-#define BOOST_PREPROCESSOR_MOD(X,Y) BOOST_PP_MOD(X,Y)
+#define BOOST_PP_MOD_C(D,RY) BOOST_PP_LESS_EQUAL_D(D,BOOST_PP_TUPLE_ELEM(2,1,RY),BOOST_PP_TUPLE_ELEM(2,0,RY))
+#define BOOST_PP_MOD_F(D,RY) (BOOST_PP_SUB_D(D,BOOST_PP_TUPLE_ELEM(2,0,RY),BOOST_PP_TUPLE_ELEM(2,1,RY)),BOOST_PP_TUPLE_ELEM(2,1,RY))
 #endif
diff --git a/boost/boost/preprocessor/arithmetic/mul.hpp b/boost/boost/preprocessor/arithmetic/mul.hpp
index 2ab66fdf8b..e6af287cde 100644
--- a/boost/boost/preprocessor/arithmetic/mul.hpp
+++ b/boost/boost/preprocessor/arithmetic/mul.hpp
@@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_MUL(4,3)</code> expands to <code>12</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -35,16 +30,9 @@ single token).</p>
 */
 #define BOOST_PP_MUL(X,Y) BOOST_PP_MUL_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_MUL_D(D,X,Y) BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_MUL_C,BOOST_PP_MUL_F,(0,X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_MUL_C(D,P) BOOST_PP_TUPLE_ELEM(3,2,P)
-#  define BOOST_PP_MUL_F(D,P) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P)),BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,P)))
-#else
-#  define BOOST_PP_MUL_C(D,P) BOOST_PP_TUPLE3_ELEM2 P
-#  define BOOST_PP_MUL_F(D,P) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P),BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_DEC(BOOST_PP_TUPLE3_ELEM2 P))
-#endif
 
-/* <p>Obsolete. Use BOOST_PP_MUL().</p> */
-#define BOOST_PREPROCESSOR_MUL(X,Y) BOOST_PP_MUL(X,Y)
+#define BOOST_PP_MUL_C(D,RXC) BOOST_PP_TUPLE_ELEM(3,2,RXC)
+#define BOOST_PP_MUL_F(D,RXC) (BOOST_PP_ADD_D(D,BOOST_PP_TUPLE_ELEM(3,0,RXC),BOOST_PP_TUPLE_ELEM(3,1,RXC)),BOOST_PP_TUPLE_ELEM(3,1,RXC),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,RXC)))
 #endif
diff --git a/boost/boost/preprocessor/arithmetic/sub.hpp b/boost/boost/preprocessor/arithmetic/sub.hpp
index 9fece281dd..7c0844aa63 100644
--- a/boost/boost/preprocessor/arithmetic/sub.hpp
+++ b/boost/boost/preprocessor/arithmetic/sub.hpp
@@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_SUB(4,3)</code> expands to <code>1</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -37,16 +32,9 @@ single token).</p>
 */
 #define BOOST_PP_SUB(X,Y) BOOST_PP_SUB_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_SUB_D(D,X,Y) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_SUB_C,BOOST_PP_SUB_F,(X,Y)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_SUB_C(D,P) BOOST_PP_TUPLE_ELEM(2,1,P)
-#  define BOOST_PP_SUB_F(D,P) (BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,0,P)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,P)))
-#else
-#  define BOOST_PP_SUB_C(D,P) BOOST_PP_TUPLE2_ELEM1 P
-#  define BOOST_PP_SUB_F(D,P) (BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM0 P),BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 P))
-#endif
 
-/* <p>Obsolete. Use BOOST_PP_SUB(X,Y).</p> */
-#define BOOST_PREPROCESSOR_SUB(X,Y) BOOST_PP_SUB(X,Y)
+#define BOOST_PP_SUB_C(D,RC) BOOST_PP_TUPLE_ELEM(2,1,RC)
+#define BOOST_PP_SUB_F(D,RC) (BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,0,RC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,RC)))
 #endif
diff --git a/boost/boost/preprocessor/assert_msg.hpp b/boost/boost/preprocessor/assert_msg.hpp
index ff36db3fbe..1f1abb456c 100644
--- a/boost/boost/preprocessor/assert_msg.hpp
+++ b/boost/boost/preprocessor/assert_msg.hpp
@@ -24,7 +24,4 @@
 <p>For example, <code>BOOST_PP_ASSERT_MSG(1,A BUG!)</code> expands to <code>A BUG!</code>.</p>
 */
 #define BOOST_PP_ASSERT_MSG(COND,MSG) BOOST_PP_EXPR_IF(BOOST_PP_NOT(COND),MSG)
-
-/* <p>Obsolete. Use BOOST_PP_ASSERT_MSG().</p> */
-#define BOOST_PREPROCESSOR_ASSERT_MSG(C,MSG) BOOST_PP_ASSERT_MSG(C,MSG)
 #endif
diff --git a/boost/boost/preprocessor/cat.hpp b/boost/boost/preprocessor/cat.hpp
index e5bc9d9e39..2fa3a27be0 100644
--- a/boost/boost/preprocessor/cat.hpp
+++ b/boost/boost/preprocessor/cat.hpp
@@ -32,7 +32,4 @@ expanded.</p>
 
 #define BOOST_PP_CAT_DELAY(X,Y) BOOST_PP_DO_CAT(X,Y)
 #define BOOST_PP_DO_CAT(X,Y) X##Y
-
-/* <p>Obsolete. Use BOOST_PP_CAT().</p> */
-#define BOOST_PREPROCESSOR_CAT(X,Y) BOOST_PP_CAT(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comma.hpp b/boost/boost/preprocessor/comma.hpp
index a17a2108b1..6b1504d1aa 100644
--- a/boost/boost/preprocessor/comma.hpp
+++ b/boost/boost/preprocessor/comma.hpp
@@ -32,7 +32,4 @@ BOOST_PP_IF(1,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
 </ul>
 */
 #define BOOST_PP_COMMA() ,
-
-/* <p>Obsolete. Use BOOST_PP_COMMA().</p> */
-#define BOOST_PREPROCESSOR_COMMA() ,
 #endif
diff --git a/boost/boost/preprocessor/comma_if.hpp b/boost/boost/preprocessor/comma_if.hpp
index a3b49d3a2d..2232505a21 100644
--- a/boost/boost/preprocessor/comma_if.hpp
+++ b/boost/boost/preprocessor/comma_if.hpp
@@ -25,7 +25,4 @@
 <p>For example, <code>BOOST_PP_COMMA_IF(0)</code> expands to nothing.</p>
 */
 #define BOOST_PP_COMMA_IF(COND) BOOST_PP_IF(COND,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
-
-/* <p>Obsolete. Use BOOST_PP_COMMA_IF().</p> */
-#define BOOST_PREPROCESSOR_COMMA_IF(C) BOOST_PP_COMMA_IF(C)
 #endif
diff --git a/boost/boost/preprocessor/comparison/equal.hpp b/boost/boost/preprocessor/comparison/equal.hpp
index 3802876431..b5a447cf60 100644
--- a/boost/boost/preprocessor/comparison/equal.hpp
+++ b/boost/boost/preprocessor/comparison/equal.hpp
@@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_EQUAL(4,4)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -36,9 +31,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_EQUAL(X,Y) BOOST_PP_EQUAL_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_EQUAL_D(D,X,Y) BOOST_PP_NOT(BOOST_PP_NOT_EQUAL_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_EQUAL(X,Y) BOOST_PP_EQUAL(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comparison/greater.hpp b/boost/boost/preprocessor/comparison/greater.hpp
index 09c137b8eb..f1e6778b8f 100644
--- a/boost/boost/preprocessor/comparison/greater.hpp
+++ b/boost/boost/preprocessor/comparison/greater.hpp
@@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_GREATER(4,3)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -35,9 +30,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_GREATER(X,Y) BOOST_PP_GREATER_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_GREATER_D(D,X,Y) BOOST_PP_LESS_D(D,Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_GREATER().</p> */
-#define BOOST_PREPROCESSOR_GREATER(X,Y) BOOST_PP_GREATER(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comparison/greater_equal.hpp b/boost/boost/preprocessor/comparison/greater_equal.hpp
index c327543d01..0ce8eb9805 100644
--- a/boost/boost/preprocessor/comparison/greater_equal.hpp
+++ b/boost/boost/preprocessor/comparison/greater_equal.hpp
@@ -23,11 +23,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_GREATER_EQUAL(1,3)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -35,9 +30,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_GREATER_EQUAL(X,Y) BOOST_PP_GREATER_EQUAL_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_GREATER_EQUAL_D(D,X,Y) BOOST_PP_LESS_EQUAL_D(D,Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_GREATER_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_GREATER_EQUAL(X,Y) BOOST_PP_GREATER_EQUAL(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comparison/less.hpp b/boost/boost/preprocessor/comparison/less.hpp
index 9d0a197822..c96ec039e8 100644
--- a/boost/boost/preprocessor/comparison/less.hpp
+++ b/boost/boost/preprocessor/comparison/less.hpp
@@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_LESS(2,6)</code> expands to <code>1</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -37,9 +32,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_LESS(X,Y) BOOST_PP_LESS_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LESS_D(D,X,Y) BOOST_PP_AND(BOOST_PP_NOT_EQUAL_D(D,X,Y),BOOST_PP_LESS_EQUAL_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_LESS().</p> */
-#define BOOST_PREPROCESSOR_LESS(X,Y) BOOST_PP_LESS(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comparison/less_equal.hpp b/boost/boost/preprocessor/comparison/less_equal.hpp
index fa8e69f949..bb0b417426 100644
--- a/boost/boost/preprocessor/comparison/less_equal.hpp
+++ b/boost/boost/preprocessor/comparison/less_equal.hpp
@@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_LESS_EQUAL(7,5)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -36,9 +31,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_LESS_EQUAL(X,Y) BOOST_PP_LESS_EQUAL_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LESS_EQUAL_D(D,X,Y) BOOST_PP_NOT(BOOST_PP_SUB_D(D,X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_LESS_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_LESS_EQUAL(X,Y) BOOST_PP_LESS_EQUAL(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/comparison/not_equal.hpp b/boost/boost/preprocessor/comparison/not_equal.hpp
index 82ae0b603c..ed8cd200ef 100644
--- a/boost/boost/preprocessor/comparison/not_equal.hpp
+++ b/boost/boost/preprocessor/comparison/not_equal.hpp
@@ -25,11 +25,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_NOT_EQUAL(4,4)</code> expands to <code>0</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -37,9 +32,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 */
 #define BOOST_PP_NOT_EQUAL(X,Y) BOOST_PP_NOT_EQUAL_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_NOT_EQUAL_D(D,X,Y) BOOST_PP_BOOL(BOOST_PP_ADD_D(D,BOOST_PP_SUB_D(D,X,Y),BOOST_PP_SUB_D(D,Y,X)))
-
-/* <p>Obsolete. Use BOOST_PP_NOT_EQUAL().</p> */
-#define BOOST_PREPROCESSOR_NOT_EQUAL(X,Y) BOOST_PP_NOT_EQUAL(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/dec.hpp b/boost/boost/preprocessor/dec.hpp
index 35718ef11a..f4145225c2 100644
--- a/boost/boost/preprocessor/dec.hpp
+++ b/boost/boost/preprocessor/dec.hpp
@@ -13,6 +13,8 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+
 /** <p>Decrements <code>X</code> expanding to a single token.</p>
 
 <p>For example, <code>BOOST_PP_DEC(3)</code> expands to <code>2</code> (a
@@ -23,9 +25,8 @@ single token).</p>
 <p>Only decimal integer literals in the range [0,BOOST_PP_LIMIT_MAG] are
 supported.</p>
 */
-#define BOOST_PP_DEC(X) BOOST_PP_DEC_DELAY(X)
+#define BOOST_PP_DEC(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_DEC,X)
 
-#define BOOST_PP_DEC_DELAY(X) BOOST_PP_DEC##X
 #define BOOST_PP_DEC0 0
 #define BOOST_PP_DEC1 0
 #define BOOST_PP_DEC2 1
@@ -155,7 +156,4 @@ supported.</p>
 #define BOOST_PP_DEC126 125
 #define BOOST_PP_DEC127 126
 #define BOOST_PP_DEC128 127
-
-/* <p>Obsolete. Use BOOST_PP_DEC().</p> */
-#define BOOST_PREPROCESSOR_DEC(X) BOOST_PP_DEC(X)
 #endif
diff --git a/boost/boost/preprocessor/empty.hpp b/boost/boost/preprocessor/empty.hpp
index 250450c845..f97d5bcaf2 100644
--- a/boost/boost/preprocessor/empty.hpp
+++ b/boost/boost/preprocessor/empty.hpp
@@ -34,7 +34,4 @@ BOOST_PP_IF(0,BOOST_PP_COMMA,BOOST_PP_EMPTY)()
 </ul>
 */
 #define BOOST_PP_EMPTY()
-
-/* <p>Obsolete. Use BOOST_PP_EMPTY().</p> */
-#define BOOST_PREPROCESSOR_EMPTY()
 #endif
diff --git a/boost/boost/preprocessor/enum.hpp b/boost/boost/preprocessor/enum.hpp
index c11222ca21..888e9a35a0 100644
--- a/boost/boost/preprocessor/enum.hpp
+++ b/boost/boost/preprocessor/enum.hpp
@@ -39,9 +39,16 @@ BOOST_PP_ENUM(3,TYPED_PARAM,(X,x))
 X0 x0, X1 x1, X2 x2
 </pre>
 
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p>BOOST_PP_ENUM() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
 <ul>
-  <li>BOOST_PP_REPEAT()</li>
+  <li>BOOST_PP_FOR()</li>
+  <li>BOOST_PP_LIMIT_DIM</li>
+  <li>BOOST_PP_LIMIT_MAG</li>
 </ul>
 
 <h3>Test</h3>
@@ -49,11 +56,54 @@ X0 x0, X1 x1, X2 x2
   <li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
 </ul>
 */
-#define BOOST_PP_ENUM(COUNT,MACRO,DATA) BOOST_PP_REPEAT(COUNT,BOOST_PP_ENUM_F,(MACRO,DATA))
+#if 0
+#  define BOOST_PP_ENUM(COUNT,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_ENUM_AUTO_REC3/4/etc. wrapping as the maximum level of 
+ * nesting REPEATS increases
+ */
+#  define BOOST_PP_ENUM\
+    BOOST_PP_AUTO_REC_CAT1(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC2(\
+      BOOST_PP_ENUM_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+      ))
+
+#  define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC1(M,P)\
+    BOOST_PP_AUTO_REC_CAT2(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#  define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC2(M,P)\
+    BOOST_PP_AUTO_REC_CAT3(BOOST_PP_ENUM_,BOOST_PP_ENUM_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#  define BOOST_PP_ENUM_BOOST_PP_ENUM_AUTO_REC3(M,P)\
+    (TOO MANY NESTED REPEATS!)
+
+#  define BOOST_PP_ENUM_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#  define BOOST_PP_ENUM_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#  define BOOST_PP_ENUM_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#  define BOOST_PP_ENUM_1(C,M,D) BOOST_PP_ENUM_AUTO_REC1(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M1,(M,D)))
+#  define BOOST_PP_ENUM_2(C,M,D) BOOST_PP_ENUM_AUTO_REC2(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M2,(M,D)))
+#  define BOOST_PP_ENUM_3(C,M,D) BOOST_PP_ENUM_AUTO_REC3(BOOST_PP_REPEAT,(C,BOOST_PP_ENUM_M3,(M,D)))
 
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_ENUM_F(I,FP) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,FP)(I,BOOST_PP_TUPLE_ELEM(2,1,FP))
 #else
-#  define BOOST_PP_ENUM_F(I,FP) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE2_ELEM0 FP(I,BOOST_PP_TUPLE2_ELEM1 FP)
+
+#  define BOOST_PP_ENUM\
+    BOOST_PP_AUTO_REC_CAT1(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#  define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC1(M,P)\
+    BOOST_PP_AUTO_REC_CAT2(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#  define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC2(M,P)\
+    BOOST_PP_AUTO_REC_CAT3(BOOST_PP_ENUM,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#  define BOOST_PP_ENUMBOOST_PP_REPEAT_AUTO_REC3(M,P)\
+    (TOO MANY NESTED REPEATS!)
+
+#  define BOOST_PP_ENUM1(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M1,(M,D))
+#  define BOOST_PP_ENUM2(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M2,(M,D))
+#  define BOOST_PP_ENUM3(C,M,D) BOOST_PP_REPEAT(C,BOOST_PP_ENUM_M3,(M,D))
+
 #endif
+
+#define BOOST_PP_ENUM_M1(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
+#define BOOST_PP_ENUM_M2(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
+#define BOOST_PP_ENUM_M3(I,MD) BOOST_PP_COMMA_IF(I) BOOST_PP_TUPLE_ELEM(2,0,MD)(I,BOOST_PP_TUPLE_ELEM(2,1,MD))
 #endif
diff --git a/boost/boost/preprocessor/enum_params.hpp b/boost/boost/preprocessor/enum_params.hpp
index 8754ee17c1..3774f46da2 100644
--- a/boost/boost/preprocessor/enum_params.hpp
+++ b/boost/boost/preprocessor/enum_params.hpp
@@ -49,7 +49,4 @@ x0, x1, x2
 #define BOOST_PP_ENUM_PARAMS(COUNT,PARAM) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_F,PARAM)
 
 #define BOOST_PP_ENUM_PARAMS_F(I,P) BOOST_PP_CAT(P,I)
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS(N,P) BOOST_PP_ENUM_PARAMS(N,P)
 #endif
diff --git a/boost/boost/preprocessor/enum_params_with_a_default.hpp b/boost/boost/preprocessor/enum_params_with_a_default.hpp
index 1b31a634c2..cb1629d9d7 100644
--- a/boost/boost/preprocessor/enum_params_with_a_default.hpp
+++ b/boost/boost/preprocessor/enum_params_with_a_default.hpp
@@ -51,12 +51,5 @@ x0 = y, x1 = y, x2 = y
 */
 #define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(COUNT,PARAM,DEFAULT) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F,(PARAM,DEFAULT))
 
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_TUPLE_ELEM(2,1,PD)
-#else
-#  define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM0 PD,I)=BOOST_PP_TUPLE2_ELEM1 PD
-#endif
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT(N,P,D) BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(N,P,D)
+#define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_TUPLE_ELEM(2,1,PD)
 #endif
diff --git a/boost/boost/preprocessor/enum_params_with_defaults.hpp b/boost/boost/preprocessor/enum_params_with_defaults.hpp
index 5281f02355..68e75a5dee 100644
--- a/boost/boost/preprocessor/enum_params_with_defaults.hpp
+++ b/boost/boost/preprocessor/enum_params_with_defaults.hpp
@@ -51,12 +51,5 @@ x0 = y0, x1 = y1, x2 = y2
 */
 #define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS(COUNT,PARAM,DEFAULT) BOOST_PP_ENUM(COUNT,BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F,(PARAM,DEFAULT))
 
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,PD),I)
-#else
-#  define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM0 PD,I)=BOOST_PP_CAT(BOOST_PP_TUPLE2_ELEM1 PD,I)
-#endif
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS(N,P,D) BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS(N,P,D)
+#define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS_F(I,PD) BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,PD),I)=BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,1,PD),I)
 #endif
diff --git a/boost/boost/preprocessor/enum_shifted.hpp b/boost/boost/preprocessor/enum_shifted.hpp
index 9204614a3a..f0ba1b4fd4 100644
--- a/boost/boost/preprocessor/enum_shifted.hpp
+++ b/boost/boost/preprocessor/enum_shifted.hpp
@@ -46,9 +46,5 @@ X1 x1, X2 x2
 */
 #define BOOST_PP_ENUM_SHIFTED(COUNT,MACRO,DATA) BOOST_PP_ENUM(BOOST_PP_DEC(COUNT),BOOST_PP_ENUM_SHIFTED_F,(MACRO,DATA))
 
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_ENUM_SHIFTED_F(I,FP) BOOST_PP_TUPLE_ELEM(2,0,FP)(BOOST_PP_INC(I),BOOST_PP_TUPLE_ELEM(2,1,FP))
-#else
-#  define BOOST_PP_ENUM_SHIFTED_F(I,FP) BOOST_PP_TUPLE2_ELEM0 FP(BOOST_PP_INC(I),BOOST_PP_TUPLE2_ELEM1 FP)
-#endif
+#define BOOST_PP_ENUM_SHIFTED_F(I,MD) BOOST_PP_TUPLE_ELEM(2,0,MD)(BOOST_PP_INC(I),BOOST_PP_TUPLE_ELEM(2,1,MD))
 #endif
diff --git a/boost/boost/preprocessor/enum_shifted_params.hpp b/boost/boost/preprocessor/enum_shifted_params.hpp
index 58bce38302..46df958680 100644
--- a/boost/boost/preprocessor/enum_shifted_params.hpp
+++ b/boost/boost/preprocessor/enum_shifted_params.hpp
@@ -54,7 +54,4 @@ x1, x2
 #define BOOST_PP_ENUM_SHIFTED_PARAMS(COUNT,PARAM) BOOST_PP_ENUM_SHIFTED(COUNT,BOOST_PP_ENUM_SHIFTED_PARAMS_F,PARAM)
 
 #define BOOST_PP_ENUM_SHIFTED_PARAMS_F(I,P) BOOST_PP_CAT(P,I)
-
-/* <p>Obsolete. Use BOOST_PP_ENUM_SHIFTED_PARAMS().</p> */
-#define BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS(N,P) BOOST_PP_ENUM_SHIFTED_PARAMS(N,P)
 #endif
diff --git a/boost/boost/preprocessor/expr_if.hpp b/boost/boost/preprocessor/expr_if.hpp
index 7122c3f6b0..b748264060 100644
--- a/boost/boost/preprocessor/expr_if.hpp
+++ b/boost/boost/preprocessor/expr_if.hpp
@@ -13,6 +13,7 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
 #include <boost/preprocessor/logical/bool.hpp>
 
 /** <p>Expands to <code>EXPR</code> if <code>COND != 0</code> and to nothing if <code>COND == 0</code>.</p>
@@ -26,10 +27,8 @@
   <li>BOOST_PP_IF()</li>
 </ul>
 */
-#define BOOST_PP_EXPR_IF(COND,EXPR) BOOST_PP_EXPR_IF_BOOL(BOOST_PP_BOOL(COND))(EXPR)
+#define BOOST_PP_EXPR_IF(COND,EXPR) BOOST_PP_DETAIL_CAT2(BOOST_PP_EXPR_IF,BOOST_PP_BOOL(COND))(EXPR)
 
-#define BOOST_PP_EXPR_IF_BOOL(C) BOOST_PP_EXPR_IF_BOOL_DELAY(C)
-#define BOOST_PP_EXPR_IF_BOOL_DELAY(C) BOOST_PP_EXPR_IF_BOOL##C
-#define BOOST_PP_EXPR_IF_BOOL0(E)
-#define BOOST_PP_EXPR_IF_BOOL1(E) E
+#define BOOST_PP_EXPR_IF0(E)
+#define BOOST_PP_EXPR_IF1(E) E
 #endif
diff --git a/boost/boost/preprocessor/for.hpp b/boost/boost/preprocessor/for.hpp
index d6dab323ba..d91b32d35d 100644
--- a/boost/boost/preprocessor/for.hpp
+++ b/boost/boost/preprocessor/for.hpp
@@ -75,6 +75,14 @@ still quite useful on its own.</p>
 <p>BOOST_PP_FOR() can be used for multidimensional repetition simply by
 invoking BOOST_PP_FOR##R() directly.</p>
 
+<h3>Automatic recursion?</h3>
+
+<p>BOOST_PP_FOR() currently does not implement automatic recursion. The reason
+for this is that it would lead to very poor performance. The automatic recursion
+technique takes O(N) steps just to find out that the Nth recursion should be used.
+This would dramatically effect the time complexity of macros using automatic
+recursion.</p>
+
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/for_test.cpp">for_test.cpp</a></li>
@@ -213,5 +221,5 @@ invoking BOOST_PP_FOR##R() directly.</p>
 #define BOOST_PP_FOR126(S,P,O,M) BOOST_PP_FOR_C0(P,127,S,M)(127,S) BOOST_PP_FOR_C1(P,127,S)(O(127,S),P,O,M)
 #define BOOST_PP_FOR127(S,P,O,M) BOOST_PP_FOR_C0(P,128,S,M)(128,S) BOOST_PP_FOR_C1(P,128,S)(O(128,S),P,O,M)
 #define BOOST_PP_FOR128(S,P,O,M) BOOST_PP_FOR_C0(P,129,S,M)(129,S) BOOST_PP_FOR_C1(P,129,S)(O(129,S),P,O,M)
-#define BOOST_PP_FOR129(S,P,O,M) RECURSION DEPTH EXCEEDED!
+#define BOOST_PP_FOR129(S,P,O,M) (RECURSION DEPTH EXCEEDED!)
 #endif
diff --git a/boost/boost/preprocessor/identity.hpp b/boost/boost/preprocessor/identity.hpp
index a39e9b6c0c..3235256e3a 100644
--- a/boost/boost/preprocessor/identity.hpp
+++ b/boost/boost/preprocessor/identity.hpp
@@ -38,7 +38,4 @@ X
 </ul>
 */
 #define BOOST_PP_IDENTITY(X) X BOOST_PP_EMPTY
-
-/* <p>Obsolete. Use BOOST_PP_IDENTITY().</p> */
-#define BOOST_PREPROCESSOR_IDENTITY(X) BOOST_PP_IDENTITY(X)
 #endif
diff --git a/boost/boost/preprocessor/if.hpp b/boost/boost/preprocessor/if.hpp
index e61a4e6dd3..1a6266acae 100644
--- a/boost/boost/preprocessor/if.hpp
+++ b/boost/boost/preprocessor/if.hpp
@@ -13,8 +13,8 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
 #include <boost/preprocessor/logical/bool.hpp>
-#include <boost/preprocessor/tuple/elem.hpp>
 
 /** <p>Expands to <code>THEN</code> if <code>COND != 0</code> and <code>ELSE</code> if
 <code>COND == 0</code>.</p>
@@ -33,11 +33,7 @@
   <li><a href="../../test/preprocessor_test.cpp">preprocessor_test.cpp</a></li>
 </ul>
 */
-#define BOOST_PP_IF(COND,THEN,ELSE) BOOST_PP_IF_BOOL(BOOST_PP_BOOL(COND))(ELSE,THEN)
-
-#define BOOST_PP_IF_BOOL(C) BOOST_PP_IF_BOOL_DELAY(C)
-#define BOOST_PP_IF_BOOL_DELAY(C) BOOST_PP_TUPLE2_ELEM##C
-
-/* <p>Obsolete. Use BOOST_PP_IF().</p> */
-#define BOOST_PREPROCESSOR_IF(C,T,E) BOOST_PP_IF(C,T,E)
+#define BOOST_PP_IF(COND,THEN,ELSE) BOOST_PP_DETAIL_CAT2(BOOST_PP_IF,BOOST_PP_BOOL(COND))(ELSE,THEN)
+#define BOOST_PP_IF0(E,T) E
+#define BOOST_PP_IF1(E,T) T
 #endif
diff --git a/boost/boost/preprocessor/inc.hpp b/boost/boost/preprocessor/inc.hpp
index c253376653..8bf735b38f 100644
--- a/boost/boost/preprocessor/inc.hpp
+++ b/boost/boost/preprocessor/inc.hpp
@@ -13,6 +13,8 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+
 /** <p>Increments <code>X</code> expanding to a single token.</p>
 
 <p>For example, <code>BOOST_PP_INC(3)</code> expands to <code>4</code> (a
@@ -24,9 +26,8 @@ BOOST_PP_LIMIT_MAG yields a BOOST_PP_LIMIT_MAG.</p>
 <p>Only decimal integer literals in the range [0,BOOST_PP_LIMIT_MAG] are
 supported.</p>
 */
-#define BOOST_PP_INC(X) BOOST_PP_INC_DELAY(X)
+#define BOOST_PP_INC(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_INC,X)
 
-#define BOOST_PP_INC_DELAY(X) BOOST_PP_INC##X
 #define BOOST_PP_INC0 1
 #define BOOST_PP_INC1 2
 #define BOOST_PP_INC2 3
@@ -156,7 +157,4 @@ supported.</p>
 #define BOOST_PP_INC126 127
 #define BOOST_PP_INC127 128
 #define BOOST_PP_INC128 128
-
-/* <p>Obsolete. Use BOOST_PP_INC().</p> */
-#define BOOST_PREPROCESSOR_INC(X) BOOST_PP_INC(X)
 #endif
diff --git a/boost/boost/preprocessor/limits.hpp b/boost/boost/preprocessor/limits.hpp
index 4361926c46..107bb81296 100644
--- a/boost/boost/preprocessor/limits.hpp
+++ b/boost/boost/preprocessor/limits.hpp
@@ -16,16 +16,16 @@
 /** <p>Expands to the number of dimensions of repeat supported by the
 library.</p>
 
-<p>The repeat macros are named BOOST_PP_REPEAT(), BOOST_PP_REPEAT_2ND(),
-BOOST_PP_REPEAT_3RD(), ...</p>
+<p>This concerns the repetition primitives (BOOST_PP_ENUM(),
+BOOST_PP_REPEAT() and BOOST_PP_REPEAT_FROM_TO()).</p>
 */
 #define BOOST_PP_LIMIT_DIM 3
 
 /** <p>Expands to the maximum straight numeric literal supported by the
 library.</p>
 
-<p>This is also the limit of the repetition primitives (BOOST_PP_ENUM family
-and BOOST_PP_REPEAT family).</p>
+<p>This is also the limit of the repetition primitives (BOOST_PP_ENUM(),
+BOOST_PP_REPEAT() and BOOST_PP_REPEAT_FROM_TO()).</p>
 
 <h3>Note</h3>
 <ul>
@@ -41,13 +41,4 @@ and BOOST_PP_REPEAT family).</p>
 
 /** <p>Expands to the maximum tuple size supported by the library.</p> */
 #define BOOST_PP_LIMIT_TUPLE 16
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_DIM.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_DIM BOOST_PP_LIMIT_DIM
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_MAG.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_MAG BOOST_PP_LIMIT_MAG
-
-/* <p>Obsolete. Use BOOST_PP_LIMIT_TUPLE.</p> */
-#define BOOST_PREPROCESSOR_LIMIT_TUPLE BOOST_PP_LIMIT_TUPLE
 #endif
diff --git a/boost/boost/preprocessor/list.hpp b/boost/boost/preprocessor/list.hpp
index 77dc79adad..343a97a061 100644
--- a/boost/boost/preprocessor/list.hpp
+++ b/boost/boost/preprocessor/list.hpp
@@ -13,14 +13,25 @@
  * See http://www.boost.org for most recent version.
  */
 
-/** <p>Includes all list headers.</p> */
+/** <p>Includes all list headers.</p>
+
+<p>A list is an arbitrary size collection of elements.</p>
+
+<p>In the preprocessor library, the internal representation of lists
+uses parts that are like macro parameter lists. Thus an element of a list
+can be any sequence of tokens that constitutes a single macro parameter.</p>
+
+<p>Lists are manipulated using both list ADT macros and higher-order macros. For an introduction to manipulation of lists in functional programming, see
+<a href="../bibliography.htm#[Thompson]">[Thompson]</a>,
+<a href="../bibliography.htm#[Abelson]">[Abelson]</a> or
+<a href="../bibliography.htm#[Cousineau]">[Cousineau]</a>.</p>
+*/
 
 #include <boost/preprocessor/list/append.hpp>
 #include <boost/preprocessor/list/at.hpp>
 #include <boost/preprocessor/list/cat.hpp>
 #include <boost/preprocessor/list/filter.hpp>
 #include <boost/preprocessor/list/first_n.hpp>
-#include <boost/preprocessor/list/fold_right_2nd.hpp>
 #include <boost/preprocessor/list/for_each.hpp>
 #include <boost/preprocessor/list/for_each_product.hpp>
 #include <boost/preprocessor/list/size.hpp>
diff --git a/boost/boost/preprocessor/list/adt.hpp b/boost/boost/preprocessor/list/adt.hpp
index f599a90bf5..38004377d1 100644
--- a/boost/boost/preprocessor/list/adt.hpp
+++ b/boost/boost/preprocessor/list/adt.hpp
@@ -49,10 +49,10 @@ BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5))
 <p>Both of the above lists contain 5 elements: 1, 2, 3, 4 and 5.</p>
 
 <p>Longer lists can be built from short lists with BOOST_PP_LIST_APPEND_D()
-and BOOST_PP_LIST_FOLD_RIGHT_2ND():</p>
+and BOOST_PP_LIST_FOLD_RIGHT():</p>
 
 <pre>
-BOOST_PP_LIST_FOLD_RIGHT_2ND
+BOOST_PP_LIST_FOLD_RIGHT
 ( BOOST_PP_LIST_APPEND_D
 , BOOST_PP_TUPLE_TO_LIST
   ( N
@@ -61,6 +61,7 @@ BOOST_PP_LIST_FOLD_RIGHT_2ND
   , ...
   , BOOST_PP_TUPLE_TO_LIST(M, (EN1, EN2, ..., ENM) )
   )
+, BOOST_PP_LIST_NIL
 )
 </pre>
 */
@@ -70,18 +71,10 @@ BOOST_PP_LIST_FOLD_RIGHT_2ND
 #define BOOST_PP_LIST_NIL (_,_,0)
 
 /** <p>Expands to 1 if the list is not nil and 0 otherwise.</p> */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE_ELEM(3,2,LIST)
-#else
-#  define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE3_ELEM2 LIST
-#endif
+#define BOOST_PP_LIST_IS_CONS(LIST) BOOST_PP_TUPLE_ELEM(3,2,LIST)
 
 /** <p>Expands to 1 if the list is nil and 0 otherwise.</p> */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE_ELEM(3,2,LIST))
-#else
-#  define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE3_ELEM2 LIST)
-#endif
+#define BOOST_PP_LIST_IS_NIL(LIST) BOOST_PP_NOT(BOOST_PP_TUPLE_ELEM(3,2,LIST))
 
 /** <p>Expands to the first element of the list. The list must not be nil.</p>
 
@@ -93,11 +86,7 @@ BOOST_PP_LIST_FIRST(BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5)))
 
 <p>expands to 1.</p>
 */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE_ELEM(3,0,LIST)
-#else
-#  define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE3_ELEM0 LIST
-#endif
+#define BOOST_PP_LIST_FIRST(LIST) BOOST_PP_TUPLE_ELEM(3,0,LIST)
 
 /** <p>Expands to a list of all but the first element of the list.</p>
 
@@ -115,9 +104,5 @@ BOOST_PP_LIST_REST(BOOST_PP_TUPLE_TO_LIST(5,(1,2,3,4,5)))
 BOOST_PP_TUPLE_TO_LIST(4,(2,3,4,5))
 </pre>
 */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE_ELEM(3,1,LIST)
-#else
-#  define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE3_ELEM1 LIST
-#endif
+#define BOOST_PP_LIST_REST(LIST) BOOST_PP_TUPLE_ELEM(3,1,LIST)
 #endif
diff --git a/boost/boost/preprocessor/list/append.hpp b/boost/boost/preprocessor/list/append.hpp
index 8a7e14adef..c01c2b5bc3 100644
--- a/boost/boost/preprocessor/list/append.hpp
+++ b/boost/boost/preprocessor/list/append.hpp
@@ -32,11 +32,6 @@ BOOST_PP_LIST_APPEND
 BOOST_PP_TUPLE_TO_LIST(4,(1,2,3,4))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -44,7 +39,7 @@ BOOST_PP_TUPLE_TO_LIST(4,(1,2,3,4))
 */
 #define BOOST_PP_LIST_APPEND(LIST_1ST,LIST_2ND) BOOST_PP_LIST_APPEND_D(0,LIST_1ST,LIST_2ND)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_APPEND_D(D,LIST_1ST,LIST_2ND) BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_APPEND_F,LIST_1ST,LIST_2ND)
-#define BOOST_PP_LIST_APPEND_F(D,H,P) (H,P,1)
+#define BOOST_PP_LIST_APPEND_F(D,X,S) (X,S,1)
 #endif
diff --git a/boost/boost/preprocessor/list/at.hpp b/boost/boost/preprocessor/list/at.hpp
index afac0b0708..f92b61fa4f 100644
--- a/boost/boost/preprocessor/list/at.hpp
+++ b/boost/boost/preprocessor/list/at.hpp
@@ -26,11 +26,6 @@ BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)),1)
 
 <p>expands to <code>B</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -38,6 +33,6 @@ BOOST_PP_LIST_AT(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)),1)
 */
 #define BOOST_PP_LIST_AT(LIST,INDEX) BOOST_PP_LIST_AT_D(0,LIST,INDEX)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_AT_D(D,LIST,INDEX) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N_D(D,INDEX,LIST))
 #endif
diff --git a/boost/boost/preprocessor/list/cat.hpp b/boost/boost/preprocessor/list/cat.hpp
index 7a88f99792..332ff9b36b 100644
--- a/boost/boost/preprocessor/list/cat.hpp
+++ b/boost/boost/preprocessor/list/cat.hpp
@@ -30,11 +30,6 @@ BOOST_PP_LIST_CAT(BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
 123
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -42,7 +37,7 @@ BOOST_PP_LIST_CAT(BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
 */
 #define BOOST_PP_LIST_CAT(LIST) BOOST_PP_LIST_CAT_D(0,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_CAT_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_CAT_F,BOOST_PP_TUPLE3_ELEM0 LIST,BOOST_PP_TUPLE3_ELEM1 LIST)
-#define BOOST_PP_LIST_CAT_F(D,P,H) BOOST_PP_CAT(P,H)
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
+#define BOOST_PP_LIST_CAT_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_CAT_F,BOOST_PP_TUPLE_ELEM(3,0,LIST),BOOST_PP_TUPLE_ELEM(3,1,LIST))
+#define BOOST_PP_LIST_CAT_F(D,S,X) BOOST_PP_CAT(S,X)
 #endif
diff --git a/boost/boost/preprocessor/list/enum.hpp b/boost/boost/preprocessor/list/enum.hpp
index 2727d79c3c..18a9a19bc9 100644
--- a/boost/boost/preprocessor/list/enum.hpp
+++ b/boost/boost/preprocessor/list/enum.hpp
@@ -37,7 +37,7 @@ A,B,C
 */
 #define BOOST_PP_LIST_ENUM(LIST) BOOST_PP_LIST_ENUM_R(0,LIST)
 
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
 #define BOOST_PP_LIST_ENUM_R(R,LIST) BOOST_PP_LIST_FOR_EACH_I_R(R,BOOST_PP_LIST_ENUM_F,_,LIST)
 #define BOOST_PP_LIST_ENUM_F(R,_,I,X) BOOST_PP_COMMA_IF(I) X
 #endif
diff --git a/boost/boost/preprocessor/list/filter.hpp b/boost/boost/preprocessor/list/filter.hpp
index 838d546212..6426a080e3 100644
--- a/boost/boost/preprocessor/list/filter.hpp
+++ b/boost/boost/preprocessor/list/filter.hpp
@@ -30,12 +30,6 @@ BOOST_PP_LIST_FILTER(BOOST_PP_NOT_EQUAL_D,2,BOOST_PP_TUPLE_TO_LIST(3,(1,2,3)))
 BOOST_PP_TUPLE_TO_LIST(2,(1,3))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
-  <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -43,13 +37,8 @@ BOOST_PP_TUPLE_TO_LIST(2,(1,3))
 */
 #define BOOST_PP_LIST_FILTER(PRED,DATA,LIST) BOOST_PP_LIST_FILTER_D(0,PRED,DATA,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_FILTER_D(D,PRED,DATA,LIST) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_FILTER_F,LIST,(PRED,DATA,(_,_,0))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P),BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE_ELEM(3,2,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE3_ELEM2 P))
-#else
-#  define BOOST_PP_LIST_FILTER_F(D,H,P) (BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P,BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_LIST_CONS,BOOST_PP_TUPLE2_ELEM1)(H,BOOST_PP_TUPLE3_ELEM2 P))
-#endif
+
+#define BOOST_PP_LIST_FILTER_F(D,X,PDR) (BOOST_PP_TUPLE_ELEM(3,0,PDR),BOOST_PP_TUPLE_ELEM(3,1,PDR),BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,0,PDR)(D,BOOST_PP_TUPLE_ELEM(3,1,PDR),X),BOOST_PP_LIST_CONS,BOOST_PP_IF1)(X,BOOST_PP_TUPLE_ELEM(3,2,PDR)))
 #endif
diff --git a/boost/boost/preprocessor/list/first_n.hpp b/boost/boost/preprocessor/list/first_n.hpp
index f7d8da99b7..6d781d24e8 100644
--- a/boost/boost/preprocessor/list/first_n.hpp
+++ b/boost/boost/preprocessor/list/first_n.hpp
@@ -37,11 +37,6 @@ BOOST_PP_TUPLE_TO_LIST(2,(+,-))
   <li>BOOST_PP_LIST_REST_N()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -49,13 +44,10 @@ BOOST_PP_TUPLE_TO_LIST(2,(+,-))
 */
 #define BOOST_PP_LIST_FIRST_N(COUNT,LIST) BOOST_PP_LIST_FIRST_N_D(0,COUNT,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation the D parameter).</p> */
 #define BOOST_PP_LIST_FIRST_N_D(D,COUNT,LIST) BOOST_PP_LIST_REVERSE_D(D,BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_WHILE##D(BOOST_PP_LIST_FIRST_N_C,BOOST_PP_LIST_FIRST_N_F,((_,_,0),LIST,COUNT))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FIRST_N_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,X)
-#  define BOOST_PP_LIST_FIRST_N_F(D,X) ((BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,1,X)),BOOST_PP_TUPLE_ELEM(3,0,X),1),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,1,X)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,X)))
-#else
-#  define BOOST_PP_LIST_FIRST_N_C(D,X) BOOST_PP_TUPLE3_ELEM2 X
-#  define BOOST_PP_LIST_FIRST_N_F(D,X) ((BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 X,1),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_DEC(BOOST_PP_TUPLE3_ELEM2 X))
-#endif
+
+#define BOOST_PP_LIST_FIRST_N_C(D,RLC) BOOST_PP_TUPLE_ELEM(3,2,RLC)
+#define BOOST_PP_LIST_FIRST_N_F(D,RLC) ((BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,1,RLC)),BOOST_PP_TUPLE_ELEM(3,0,RLC),1),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,1,RLC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3,2,RLC)))
+
 #endif
diff --git a/boost/boost/preprocessor/list/fold_left.hpp b/boost/boost/preprocessor/list/fold_left.hpp
index 9ade0dde96..51677ade36 100644
--- a/boost/boost/preprocessor/list/fold_left.hpp
+++ b/boost/boost/preprocessor/list/fold_left.hpp
@@ -13,6 +13,8 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/auto_rec.hpp>
+#include <boost/preprocessor/expand.hpp>
 #include <boost/preprocessor/list/adt.hpp>
 #include <boost/preprocessor/while.hpp>
 
@@ -53,11 +55,6 @@ _ABC
   <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -65,16 +62,43 @@ _ABC
 */
 #define BOOST_PP_LIST_FOLD_LEFT(OP,STATE,LIST) BOOST_PP_LIST_FOLD_LEFT_D(0,OP,STATE,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_D(D,OP,STATE,LIST) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_WHILE##D(BOOST_PP_LIST_FOLD_LEFT_C,BOOST_PP_LIST_FOLD_LEFT_F,(OP,STATE,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,X))
-#  define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE_ELEM(3,0,X)(D,BOOST_PP_TUPLE_ELEM(3,1,X),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,X))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,X)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-#  define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#else
-#  define BOOST_PP_LIST_FOLD_LEFT_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-#  define BOOST_PP_LIST_FOLD_LEFT_F(D,X) (BOOST_PP_TUPLE3_ELEM0 X,BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+  <li>BOOST_PP_LIST_FOLD_LEFT_D() implements automatic recursion. You
+      can use a fold in the OP macro.</li>
+</ul>
+*/
+#if 0
+#  define BOOST_PP_LIST_FOLD_LEFT_D(D,OP,STATE,LIST)
 #endif
+
+#define BOOST_PP_LIST_FOLD_LEFT_D\
+  BOOST_PP_AUTO_REC_CAT1(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P)\
+  BOOST_PP_AUTO_REC_CAT2(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P)\
+  BOOST_PP_AUTO_REC_CAT3(BOOST_PP_LIST_FOLD_LEFT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_LIST_FOLD_LEFT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P)\
+  (TOO MANY NESTED FOLDS!)
+
+#define BOOST_PP_LIST_FOLD_LEFT_D1(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O1,(O,S,L))))
+#define BOOST_PP_LIST_FOLD_LEFT_D2(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O2,(O,S,L))))
+#define BOOST_PP_LIST_FOLD_LEFT_D3(D,O,S,L) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_WHILE##D,(BOOST_PP_LIST_FOLD_LEFT_P,BOOST_PP_LIST_FOLD_LEFT_O3,(O,S,L))))
+
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#define BOOST_PP_LIST_FOLD_LEFT_P(D,OSL) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,OSL))
+
+#define BOOST_PP_LIST_FOLD_LEFT_O1(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+#define BOOST_PP_LIST_FOLD_LEFT_O2(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+#define BOOST_PP_LIST_FOLD_LEFT_O3(D,OSL) (BOOST_PP_TUPLE_ELEM(3,0,OSL),BOOST_PP_TUPLE_ELEM(3,0,OSL)(D,BOOST_PP_TUPLE_ELEM(3,1,OSL),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,OSL))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,OSL)))
+
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_LEFT().</p> */
+#define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_LEFT_D().</p> */
+#define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D
 #endif
diff --git a/boost/boost/preprocessor/list/fold_left_2nd.hpp b/boost/boost/preprocessor/list/fold_left_2nd.hpp
index df126622d4..95b809bf34 100644
--- a/boost/boost/preprocessor/list/fold_left_2nd.hpp
+++ b/boost/boost/preprocessor/list/fold_left_2nd.hpp
@@ -13,22 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/list/adt.hpp>
-#include <boost/preprocessor/while.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-/** <p>Same as BOOST_PP_LIST_FOLD_LEFT(), but implemented independently.</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_2ND(OP,STATE,LIST) BOOST_PP_LIST_FOLD_LEFT_2ND_D(0,OP,STATE,LIST)
+<pre>
+#include &lt;boost/preprocessor/list/fold_left.hpp&gt;
+</pre>
+*/
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,OP,STATE,LIST) BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_WHILE##D(BOOST_PP_LIST_FOLD_LEFT_2ND_C,BOOST_PP_LIST_FOLD_LEFT_2ND_F,(OP,STATE,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(3,2,X))
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE_ELEM(3,0,X)(D,BOOST_PP_TUPLE_ELEM(3,1,X),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(3,2,X))),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(3,2,X)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE_ELEM(3,0,X),BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#else
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_C(D,X) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE3_ELEM2 X
-#  define BOOST_PP_LIST_FOLD_LEFT_2ND_F(D,X) (BOOST_PP_TUPLE3_ELEM0 X,BOOST_PP_TUPLE3_ELEM0 X(D,BOOST_PP_TUPLE3_ELEM1 X,BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE3_ELEM2 X),BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE3_ELEM2 X)
-#endif
+#include <boost/preprocessor/list/fold_left.hpp>
 #endif
diff --git a/boost/boost/preprocessor/list/fold_right.hpp b/boost/boost/preprocessor/list/fold_right.hpp
index c6c0b40f8e..cc28f42add 100644
--- a/boost/boost/preprocessor/list/fold_right.hpp
+++ b/boost/boost/preprocessor/list/fold_right.hpp
@@ -49,10 +49,10 @@ BOOST_PP_LIST_FOLD_RIGHT(TEST,_,BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 _CBA
 </pre>
 
-<h3>Uses</h3>
+<h3>Note</h3>
 <ul>
-  <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
+  <li>Folding, or accumulation, is a very general pattern of computation.
+      Most list operations can be implemented in terms of folding.</li>
 </ul>
 
 <h3>Test</h3>
@@ -62,13 +62,37 @@ _CBA
 */
 #define BOOST_PP_LIST_FOLD_RIGHT(OP,LIST,STATE) BOOST_PP_LIST_FOLD_RIGHT_D(0,OP,LIST,STATE)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_D(D,OP,LIST,STATE) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_F,(OP,STATE),BOOST_PP_LIST_REVERSE_D(D,LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE_ELEM(2,1,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#else
-#  define BOOST_PP_LIST_FOLD_RIGHT_F(D,P,H) (BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM0 P(D,H,BOOST_PP_TUPLE2_ELEM1 P))
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p>
+
+<h3>Note</h3>
+<ul>
+  <li>BOOST_PP_LIST_FOLD_RIGHT_D() implements automatic recursion. You
+      can use a fold in the OP macro.</li>
+</ul>
+*/
+#if 0
+#  define BOOST_PP_LIST_FOLD_RIGHT_D(D,OP,LIST,STATE)
 #endif
+
+#define BOOST_PP_LIST_FOLD_RIGHT_D\
+  BOOST_PP_AUTO_REC_CAT1(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC1(M,P)\
+  BOOST_PP_AUTO_REC_CAT2(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC2(M,P)\
+  BOOST_PP_AUTO_REC_CAT3(BOOST_PP_LIST_FOLD_RIGHT_D,BOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_LIST_FOLD_RIGHT_DBOOST_PP_LIST_FOLD_LEFT_D_AUTO_REC3(M,P)\
+  (TOO MANY NESTED FOLDS!)
+
+#define BOOST_PP_LIST_FOLD_RIGHT_D1(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O1,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+#define BOOST_PP_LIST_FOLD_RIGHT_D2(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O2,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+#define BOOST_PP_LIST_FOLD_RIGHT_D3(D,O,L,S) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_FOLD_RIGHT_O3,(O,S),BOOST_PP_LIST_REVERSE_D(D,L)))
+
+#define BOOST_PP_LIST_FOLD_RIGHT_O1(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+#define BOOST_PP_LIST_FOLD_RIGHT_O2(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+#define BOOST_PP_LIST_FOLD_RIGHT_O3(D,OS,X) (BOOST_PP_TUPLE_ELEM(2,0,OS),BOOST_PP_TUPLE_ELEM(2,0,OS)(D,X,BOOST_PP_TUPLE_ELEM(2,1,OS)))
+
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_RIGHT().</p> */
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT
+/** <p>Obsolete, just use BOOST_PP_LIST_FOLD_RIGHT_D().</p> */
+#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D 
 #endif
diff --git a/boost/boost/preprocessor/list/fold_right_2nd.hpp b/boost/boost/preprocessor/list/fold_right_2nd.hpp
index 5dada16e9d..0e99a42ca8 100644
--- a/boost/boost/preprocessor/list/fold_right_2nd.hpp
+++ b/boost/boost/preprocessor/list/fold_right_2nd.hpp
@@ -13,19 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/list/fold_left_2nd.hpp>
-#include <boost/preprocessor/list/reverse.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-/** <p>Same as BOOST_PP_LIST_FOLD_RIGHT(), but implemented independently.</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_2ND(OP,LIST,STATE) BOOST_PP_LIST_FOLD_RIGHT_2ND_D(0,OP,LIST,STATE)
+<pre>
+#include &lt;boost/preprocessor/list/fold_right.hpp&gt;
+</pre>
+*/
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
-#define BOOST_PP_LIST_FOLD_RIGHT_2ND_D(D,OP,LIST,STATE) BOOST_PP_TUPLE_ELEM(2,1,BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,BOOST_PP_LIST_FOLD_RIGHT_2ND_F,(OP,STATE),BOOST_PP_LIST_FOLD_LEFT_2ND_D(D,BOOST_PP_LIST_REVERSE_F,(_,_,0),LIST)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE_ELEM(2,1,P)))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE_ELEM(2,0,P),BOOST_PP_TUPLE_ELEM(2,0,P)(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#else
-#  define BOOST_PP_LIST_FOLD_RIGHT_2ND_F(D,P,H) (BOOST_PP_TUPLE2_ELEM0 P,BOOST_PP_TUPLE2_ELEM0 P(D,H,BOOST_PP_TUPLE2_ELEM1 P))
-#endif
+#include <boost/preprocessor/list/fold_right.hpp>
 #endif
diff --git a/boost/boost/preprocessor/list/for_each.hpp b/boost/boost/preprocessor/list/for_each.hpp
index fe826e8e63..151971f6af 100644
--- a/boost/boost/preprocessor/list/for_each.hpp
+++ b/boost/boost/preprocessor/list/for_each.hpp
@@ -45,12 +45,6 @@ prefix_A(); prefix_B(); prefix_C();
   <li><a href="../../example/catch_builtin.cpp">catch_builtin.cpp</a></li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
-  <li>BOOST_PP_LIST_FOR_EACH_I() </li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -58,7 +52,7 @@ prefix_A(); prefix_B(); prefix_C();
 */
 #define BOOST_PP_LIST_FOR_EACH(MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_R(0,MACRO,DATA,LIST)
 
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
 #define BOOST_PP_LIST_FOR_EACH_R(R,MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_I_R(R,BOOST_PP_LIST_FOR_EACH_F,(MACRO,DATA),LIST)
-#define BOOST_PP_LIST_FOR_EACH_F(R,FP,I,X) BOOST_PP_TUPLE_ELEM(2,0,FP)(R,BOOST_PP_TUPLE_ELEM(2,1,FP),X)
+#define BOOST_PP_LIST_FOR_EACH_F(R,MD,I,X) BOOST_PP_TUPLE_ELEM(2,0,MD)(R,BOOST_PP_TUPLE_ELEM(2,1,MD),X)
 #endif
diff --git a/boost/boost/preprocessor/list/for_each_i.hpp b/boost/boost/preprocessor/list/for_each_i.hpp
index 409673f5ad..e547852e19 100644
--- a/boost/boost/preprocessor/list/for_each_i.hpp
+++ b/boost/boost/preprocessor/list/for_each_i.hpp
@@ -41,17 +41,12 @@ BOOST_PP_LIST_FOR_EACH_I(TEST,prefix_,BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 <pre>
 prefix_A(0); prefix_B(1); prefix_C(2);
 </pre>
-
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
-</ul>
 */
 #define BOOST_PP_LIST_FOR_EACH_I(MACRO,DATA,LIST) BOOST_PP_LIST_FOR_EACH_I_R(0,MACRO,DATA,LIST)
 
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
-#define BOOST_PP_LIST_FOR_EACH_I_R(R,MACRO,DATA,LIST) BOOST_PP_FOR##R((MACRO,DATA,LIST,0),BOOST_PP_LIST_FOR_EACH_I_C,BOOST_PP_LIST_FOR_EACH_I_F,BOOST_PP_LIST_FOR_EACH_I_I)
-#define BOOST_PP_LIST_FOR_EACH_I_C(R,FPLI) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,2,FPLI))
-#define BOOST_PP_LIST_FOR_EACH_I_F(R,FPLI) (BOOST_PP_TUPLE_ELEM(4,0,FPLI),BOOST_PP_TUPLE_ELEM(4,1,FPLI),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,2,FPLI)),BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4,3,FPLI)))
-#define BOOST_PP_LIST_FOR_EACH_I_I(R,FPLI) BOOST_PP_TUPLE_ELEM(4,0,FPLI)(R,BOOST_PP_TUPLE_ELEM(4,1,FPLI),BOOST_PP_TUPLE_ELEM(4,3,FPLI),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,2,FPLI)))
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
+#define BOOST_PP_LIST_FOR_EACH_I_R(R,MACRO,DATA,LIST) BOOST_PP_FOR##R((MACRO,DATA,LIST,0),BOOST_PP_LIST_FOR_EACH_I_P,BOOST_PP_LIST_FOR_EACH_I_O,BOOST_PP_LIST_FOR_EACH_I_M)
+#define BOOST_PP_LIST_FOR_EACH_I_P(R,MDLI) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,2,MDLI))
+#define BOOST_PP_LIST_FOR_EACH_I_O(R,MDLI) (BOOST_PP_TUPLE_ELEM(4,0,MDLI),BOOST_PP_TUPLE_ELEM(4,1,MDLI),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,2,MDLI)),BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4,3,MDLI)))
+#define BOOST_PP_LIST_FOR_EACH_I_M(R,MDLI) BOOST_PP_TUPLE_ELEM(4,0,MDLI)(R,BOOST_PP_TUPLE_ELEM(4,1,MDLI),BOOST_PP_TUPLE_ELEM(4,3,MDLI),BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,2,MDLI)))
 #endif
diff --git a/boost/boost/preprocessor/list/for_each_product.hpp b/boost/boost/preprocessor/list/for_each_product.hpp
index 214cd55e0c..0e7f692d53 100644
--- a/boost/boost/preprocessor/list/for_each_product.hpp
+++ b/boost/boost/preprocessor/list/for_each_product.hpp
@@ -50,11 +50,6 @@ BOOST_PP_LIST_FOR_EACH_PRODUCT
   <li><a href="../../example/array_arithmetic.c">array_arithmetic.c</a></li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_FOR() (see for explanation of the R parameter)</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -62,26 +57,17 @@ BOOST_PP_LIST_FOR_EACH_PRODUCT
 */
 #define BOOST_PP_LIST_FOR_EACH_PRODUCT(MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS) BOOST_PP_LIST_FOR_EACH_PRODUCT_R(0,MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS)
 
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
 #define BOOST_PP_LIST_FOR_EACH_PRODUCT_R(R,MACRO,SIZE_OF_TUPLE,TUPLE_OF_LISTS) BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(0,MACRO,BOOST_PP_TUPLE_TO_LIST(SIZE_OF_TUPLE,BOOST_PP_TUPLE_REVERSE(SIZE_OF_TUPLE,TUPLE_OF_LISTS)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__) ||\
-  !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE_ELEM(3,0,LL),BOOST_PP_TUPLE_ELEM(3,1,LL),(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,0,P))
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,1,P),BOOST_PP_TUPLE_ELEM(4,2,P),BOOST_PP_TUPLE_ELEM(4,3,P))
 
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE_ELEM(4,3,P)(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1)))
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,1,P)),(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1),BOOST_PP_TUPLE_ELEM(4,3,P))
-#else
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE3_ELEM0 LL,BOOST_PP_TUPLE3_ELEM1 LL,(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE4_ELEM0 P
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE4_ELEM0 P),BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_TUPLE4_ELEM2 P,BOOST_PP_TUPLE4_ELEM3 P)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_R2(R,F,LL) BOOST_PP_FOR##R((BOOST_PP_TUPLE_ELEM(3,0,LL),BOOST_PP_TUPLE_ELEM(3,1,LL),(_,_,0),F),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I0)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(R,P) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,0,P))
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_F(R,P) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,1,P),BOOST_PP_TUPLE_ELEM(4,2,P),BOOST_PP_TUPLE_ELEM(4,3,P))
+
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE_ELEM(4,3,P)(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1)))
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
+#define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,1,P)),BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(4,1,P)),(BOOST_PP_TUPLE_ELEM(3,0,BOOST_PP_TUPLE_ELEM(4,0,P)),BOOST_PP_TUPLE_ELEM(4,2,P),1),BOOST_PP_TUPLE_ELEM(4,3,P))
 
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(R,P) BOOST_PP_TUPLE4_ELEM3 P(R,BOOST_PP_LIST_TO_TUPLE_R(R,(BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM0 P,BOOST_PP_TUPLE4_ELEM2 P,1)))
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,I) BOOST_PP_IF(BOOST_PP_TUPLE3_ELEM2 BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_LIST_FOR_EACH_PRODUCT_I##I##_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_I)
-#  define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P) (BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM1 P,BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE4_ELEM1 P,(BOOST_PP_TUPLE3_ELEM0 BOOST_PP_TUPLE4_ELEM0 P,BOOST_PP_TUPLE4_ELEM2 P,1),BOOST_PP_TUPLE4_ELEM3 P)
-#endif
 #define BOOST_PP_LIST_FOR_EACH_PRODUCT_I0_C(R,P) BOOST_PP_FOR##R(BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I1)
 #define BOOST_PP_LIST_FOR_EACH_PRODUCT_I0(R,P) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_C(P,0)(R,P)
 #define BOOST_PP_LIST_FOR_EACH_PRODUCT_I1_C(R,P) BOOST_PP_FOR##R(BOOST_PP_LIST_FOR_EACH_PRODUCT_I_H(P),BOOST_PP_LIST_FOR_EACH_PRODUCT_C,BOOST_PP_LIST_FOR_EACH_PRODUCT_F,BOOST_PP_LIST_FOR_EACH_PRODUCT_I2)
diff --git a/boost/boost/preprocessor/list/rest_n.hpp b/boost/boost/preprocessor/list/rest_n.hpp
index 45ec37ddeb..0ee4787b9b 100644
--- a/boost/boost/preprocessor/list/rest_n.hpp
+++ b/boost/boost/preprocessor/list/rest_n.hpp
@@ -37,11 +37,6 @@ BOOST_PP_TUPLE_TO_LIST(2,(*,/))
   <li>BOOST_PP_LIST_FIRST_N()</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -49,13 +44,9 @@ BOOST_PP_TUPLE_TO_LIST(2,(*,/))
 */
 #define BOOST_PP_LIST_REST_N(COUNT,LIST) BOOST_PP_LIST_REST_N_D(0,COUNT,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_REST_N_D(D,COUNT,LIST) BOOST_PP_TUPLE_ELEM(2,0,BOOST_PP_WHILE##D(BOOST_PP_LIST_REST_N_C,BOOST_PP_LIST_REST_N_F,(LIST,COUNT)))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_REST_N_C(D,X) BOOST_PP_TUPLE_ELEM(2,1,X)
-#  define BOOST_PP_LIST_REST_N_F(D,X) (BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(2,0,X)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,X)))
-#else
-#  define BOOST_PP_LIST_REST_N_C(D,X) BOOST_PP_TUPLE2_ELEM1 X
-#  define BOOST_PP_LIST_REST_N_F(D,X) (BOOST_PP_TUPLE3_ELEM1 BOOST_PP_TUPLE2_ELEM0 X,BOOST_PP_DEC(BOOST_PP_TUPLE2_ELEM1 X))
-#endif
+
+#define BOOST_PP_LIST_REST_N_C(D,LC) BOOST_PP_TUPLE_ELEM(2,1,LC)
+#define BOOST_PP_LIST_REST_N_F(D,LC) (BOOST_PP_TUPLE_ELEM(3,1,BOOST_PP_TUPLE_ELEM(2,0,LC)),BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,LC)))
 #endif
diff --git a/boost/boost/preprocessor/list/reverse.hpp b/boost/boost/preprocessor/list/reverse.hpp
index 0834dce4c3..5c546f0715 100644
--- a/boost/boost/preprocessor/list/reverse.hpp
+++ b/boost/boost/preprocessor/list/reverse.hpp
@@ -29,11 +29,6 @@ BOOST_PP_LIST_REVERSE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 BOOST_PP_TUPLE_TO_LIST(3,(C,B,A))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -41,7 +36,7 @@ BOOST_PP_TUPLE_TO_LIST(3,(C,B,A))
 */
 #define BOOST_PP_LIST_REVERSE(LIST) BOOST_PP_LIST_REVERSE_D(0,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_REVERSE_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_REVERSE_F,(_,_,0),LIST)
-#define BOOST_PP_LIST_REVERSE_F(D,P,H) (H,P,1)
+#define BOOST_PP_LIST_REVERSE_F(D,S,X) (X,S,1)
 #endif
diff --git a/boost/boost/preprocessor/list/size.hpp b/boost/boost/preprocessor/list/size.hpp
index a0ce8a7a81..837fcc37e0 100644
--- a/boost/boost/preprocessor/list/size.hpp
+++ b/boost/boost/preprocessor/list/size.hpp
@@ -26,11 +26,6 @@ BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 
 <p>expands to <code>3</code>.</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_LIST_FOLD_LEFT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -38,7 +33,7 @@ BOOST_PP_LIST_SIZE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 */
 #define BOOST_PP_LIST_SIZE(LIST) BOOST_PP_LIST_SIZE_D(0,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_SIZE_D(D,LIST) BOOST_PP_LIST_FOLD_LEFT_D(D,BOOST_PP_LIST_SIZE_F,0,LIST)
-#define BOOST_PP_LIST_SIZE_F(D,P,H) BOOST_PP_INC(P)
+#define BOOST_PP_LIST_SIZE_F(D,S,X) BOOST_PP_INC(S)
 #endif
diff --git a/boost/boost/preprocessor/list/to_tuple.hpp b/boost/boost/preprocessor/list/to_tuple.hpp
index b24c957cfd..83714b3658 100644
--- a/boost/boost/preprocessor/list/to_tuple.hpp
+++ b/boost/boost/preprocessor/list/to_tuple.hpp
@@ -31,11 +31,6 @@ BOOST_PP_LIST_TO_TUPLE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
       BOOST_PP_LIMIT_MAG rather than BOOST_PP_LIMIT_TUPLE.</li>
 </ul>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_FOR()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -43,6 +38,6 @@ BOOST_PP_LIST_TO_TUPLE(BOOST_PP_TUPLE_TO_LIST(3,(A,B,C)))
 */
 #define BOOST_PP_LIST_TO_TUPLE(LIST) BOOST_PP_LIST_TO_TUPLE_R(0,LIST)
 
-/** <p>Can be used inside BOOST_PP_FOR().</p> */
+/** <p>Can be used inside BOOST_PP_FOR() (see for an explanation of the R parameter).</p> */
 #define BOOST_PP_LIST_TO_TUPLE_R(R,LIST) (BOOST_PP_LIST_ENUM_R(R,LIST))
 #endif
diff --git a/boost/boost/preprocessor/list/transform.hpp b/boost/boost/preprocessor/list/transform.hpp
index 5ab33b6416..76c9e81a43 100644
--- a/boost/boost/preprocessor/list/transform.hpp
+++ b/boost/boost/preprocessor/list/transform.hpp
@@ -40,12 +40,6 @@ BOOST_PP_LIST_TRANSFORM(BOOST_PP_ADD_D,2,BOOST_PP_TUPLE_TO_LIST(2,(1,2)))
 BOOST_PP_TUPLE_TO_LIST(2,(3,4))
 </pre>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE() (see for explanation of the D parameter)</li>
-  <li>BOOST_PP_LIST_FOLD_RIGHT()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/list_test.cpp">list_test.cpp</a></li>
@@ -53,13 +47,8 @@ BOOST_PP_TUPLE_TO_LIST(2,(3,4))
 */
 #define BOOST_PP_LIST_TRANSFORM(OP,DATA,LIST) BOOST_PP_LIST_TRANSFORM_D(0,OP,DATA,LIST)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_LIST_TRANSFORM_D(D,OP,DATA,LIST) BOOST_PP_TUPLE_ELEM(3,2,BOOST_PP_LIST_FOLD_RIGHT_D(D,BOOST_PP_LIST_TRANSFORM_F,LIST,(OP,DATA,(_,_,0))))
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE_ELEM(3,1,P),(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE_ELEM(3,1,P),H),BOOST_PP_TUPLE_ELEM(3,2,P),1))
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE_ELEM(3,0,P),BOOST_PP_TUPLE3_ELEM1 P,(BOOST_PP_TUPLE_ELEM(3,0,P)(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_TUPLE3_ELEM2 P,1))
-#else
-#  define BOOST_PP_LIST_TRANSFORM_F(D,H,P) (BOOST_PP_TUPLE3_ELEM0 P,BOOST_PP_TUPLE3_ELEM1 P,(BOOST_PP_TUPLE3_ELEM0 P(D,BOOST_PP_TUPLE3_ELEM1 P,H),BOOST_PP_TUPLE3_ELEM2 P,1))
-#endif
+
+#define BOOST_PP_LIST_TRANSFORM_F(D,X,ODR) (BOOST_PP_TUPLE_ELEM(3,0,ODR),BOOST_PP_TUPLE_ELEM(3,1,ODR),(BOOST_PP_TUPLE_ELEM(3,0,ODR)(D,BOOST_PP_TUPLE_ELEM(3,1,ODR),X),BOOST_PP_TUPLE_ELEM(3,2,ODR),1))
 #endif
diff --git a/boost/boost/preprocessor/logical/and.hpp b/boost/boost/preprocessor/logical/and.hpp
index 94598c2d7e..c34a0fc942 100644
--- a/boost/boost/preprocessor/logical/and.hpp
+++ b/boost/boost/preprocessor/logical/and.hpp
@@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 </ul>
 */
 #define BOOST_PP_AND(X,Y) BOOST_PP_NOR(BOOST_PP_NOT(X),BOOST_PP_NOT(Y))
-
-/* <p>Obsolete. Use BOOST_PP_AND().</p> */
-#define BOOST_PREPROCESSOR_AND(X,Y) BOOST_PP_AND(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/logical/bool.hpp b/boost/boost/preprocessor/logical/bool.hpp
index 35559a1b86..5f41ee883f 100644
--- a/boost/boost/preprocessor/logical/bool.hpp
+++ b/boost/boost/preprocessor/logical/bool.hpp
@@ -13,18 +13,19 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+
 /** <p>Expands to <code>0</code> if <code>X == 0</code> and <code>1</code> if <code>X != 0</code>.</p>
 
 <p><code>X</code> must be an integer literal in the range [0, BOOST_PP_LIMIT_MAG].</p>
 
 <p>For example, <code>BOOST_PP_BOOL(3)</code> expands to <code>1</code>.</p>
 */
-#define BOOST_PP_BOOL(X) BOOST_PP_BOOL_DELAY(X)
+#define BOOST_PP_BOOL(X) BOOST_PP_DETAIL_CAT2(BOOST_PP_BOOL,X)
 
 /* BOOL can be implemented in O(1) tokens using saturated ADD & SUB.
  * Unfortunately, it would result in significantly slower preprocessing.
  */
-#define BOOST_PP_BOOL_DELAY(X) BOOST_PP_BOOL##X
 #define BOOST_PP_BOOL0 0
 #define BOOST_PP_BOOL1 1
 #define BOOST_PP_BOOL2 1
@@ -154,7 +155,4 @@
 #define BOOST_PP_BOOL126 1
 #define BOOST_PP_BOOL127 1
 #define BOOST_PP_BOOL128 1
-
-/* <p>Obsolete. Use BOOST_PP_BOOL().</p> */
-#define BOOST_PREPROCESSOR_BOOL(X) BOOST_PP_BOOL(X)
 #endif
diff --git a/boost/boost/preprocessor/logical/nor.hpp b/boost/boost/preprocessor/logical/nor.hpp
index 00d787a646..d6c851c22a 100644
--- a/boost/boost/preprocessor/logical/nor.hpp
+++ b/boost/boost/preprocessor/logical/nor.hpp
@@ -13,6 +13,7 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
 #include <boost/preprocessor/logical/bool.hpp>
 
 /** <p>Expands to the logical NEITHER OR of the operands.</p>
@@ -27,15 +28,10 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
   <li><a href="../../test/logical_test.cpp">logical_test.cpp</a></li>
 </ul>
 */
-#define BOOST_PP_NOR(X,Y) BOOST_PP_NOR_BOOL(BOOST_PP_BOOL(X),BOOST_PP_BOOL(Y))
+#define BOOST_PP_NOR(X,Y) BOOST_PP_DETAIL_CAT3(BOOST_PP_NOR,BOOST_PP_BOOL(X),BOOST_PP_BOOL(Y))
 
-#define BOOST_PP_NOR_BOOL(X,Y) BOOST_PP_NOR_BOOL_DELAY(X,Y)
-#define BOOST_PP_NOR_BOOL_DELAY(X,Y) BOOST_PP_NOR_BOOL##X##Y
-#define BOOST_PP_NOR_BOOL00 1
-#define BOOST_PP_NOR_BOOL01 0
-#define BOOST_PP_NOR_BOOL10 0
-#define BOOST_PP_NOR_BOOL11 0
-
-/* <p>Obsolete. Use BOOST_PP_NOR().</p> */
-#define BOOST_PREPROCESSOR_NOR(X,Y) BOOST_PP_NOR(X,Y)
+#define BOOST_PP_NOR00 1
+#define BOOST_PP_NOR01 0
+#define BOOST_PP_NOR10 0
+#define BOOST_PP_NOR11 0
 #endif
diff --git a/boost/boost/preprocessor/logical/not.hpp b/boost/boost/preprocessor/logical/not.hpp
index 6f5e00dbe3..158998b909 100644
--- a/boost/boost/preprocessor/logical/not.hpp
+++ b/boost/boost/preprocessor/logical/not.hpp
@@ -27,7 +27,4 @@
 </ul>
 */
 #define BOOST_PP_NOT(X) BOOST_PP_NOR(X,X)
-
-/* <p>Obsolete. Use BOOST_PP_NOT().</p> */
-#define BOOST_PREPROCESSOR_NOT(X) BOOST_PP_NOT(X)
 #endif
diff --git a/boost/boost/preprocessor/logical/or.hpp b/boost/boost/preprocessor/logical/or.hpp
index 7fc863a987..0dde9f92d3 100644
--- a/boost/boost/preprocessor/logical/or.hpp
+++ b/boost/boost/preprocessor/logical/or.hpp
@@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 </ul>
 */
 #define BOOST_PP_OR(X,Y) BOOST_PP_NOT(BOOST_PP_NOR(X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_OR().</p> */
-#define BOOST_PREPROCESSOR_OR(X,Y) BOOST_PP_OR(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/logical/xor.hpp b/boost/boost/preprocessor/logical/xor.hpp
index e95f74861b..80dea6fc8a 100644
--- a/boost/boost/preprocessor/logical/xor.hpp
+++ b/boost/boost/preprocessor/logical/xor.hpp
@@ -28,7 +28,4 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 </ul>
 */
 #define BOOST_PP_XOR(X,Y) BOOST_PP_NOR(BOOST_PP_NOR(X,Y),BOOST_PP_AND(X,Y))
-
-/* <p>Obsolete. Use BOOST_PP_XOR().</p> */
-#define BOOST_PREPROCESSOR_XOR(X,Y) BOOST_PP_XOR(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/max.hpp b/boost/boost/preprocessor/max.hpp
index b8a343e178..da80b65889 100644
--- a/boost/boost/preprocessor/max.hpp
+++ b/boost/boost/preprocessor/max.hpp
@@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_MAX(5,7)</code> expands to <code>7</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -36,9 +31,6 @@ single token).</p>
 */
 #define BOOST_PP_MAX(X,Y) BOOST_PP_MAX_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_MAX_D(D,X,Y) BOOST_PP_IF(BOOST_PP_LESS_EQUAL_D(D,X,Y),Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_MAX().</p> */
-#define BOOST_PREPROCESSOR_MAX(X,Y) BOOST_PP_MAX(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/min.hpp b/boost/boost/preprocessor/min.hpp
index e345ad0d39..62516860ce 100644
--- a/boost/boost/preprocessor/min.hpp
+++ b/boost/boost/preprocessor/min.hpp
@@ -24,11 +24,6 @@ in the range [0, BOOST_PP_LIMIT_MAG].</p>
 <p>For example, <code>BOOST_PP_MIN(5,7)</code> expands to <code>5</code> (a
 single token).</p>
 
-<h3>Uses</h3>
-<ul>
-  <li>BOOST_PP_WHILE()</li>
-</ul>
-
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/arithmetic_test.cpp">arithmetic_test.cpp</a></li>
@@ -36,9 +31,6 @@ single token).</p>
 */
 #define BOOST_PP_MIN(X,Y) BOOST_PP_MIN_D(0,X,Y)
 
-/** <p>Can be used inside BOOST_PP_WHILE().</p> */
+/** <p>Can be used inside BOOST_PP_WHILE() (see for an explanation of the D parameter).</p> */
 #define BOOST_PP_MIN_D(D,X,Y) BOOST_PP_IF(BOOST_PP_LESS_EQUAL_D(D,Y,X),Y,X)
-
-/* <p>Obsolete. Use BOOST_PP_MIN().</p> */
-#define BOOST_PREPROCESSOR_MIN(X,Y) BOOST_PP_MIN(X,Y)
 #endif
diff --git a/boost/boost/preprocessor/repeat.hpp b/boost/boost/preprocessor/repeat.hpp
index 43ddfd0fc7..bbc5c367ec 100644
--- a/boost/boost/preprocessor/repeat.hpp
+++ b/boost/boost/preprocessor/repeat.hpp
@@ -13,6 +13,10 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+#include <boost/preprocessor/detail/auto_rec.hpp>
+#include <boost/preprocessor/expand.hpp>
+
 /** <p>Repeats the macro <code>MACRO(INDEX,DATA)</code> for <code>INDEX = [0,COUNT)</code>.</p>
 
 <p>In other words, expands to the sequence:</p>
@@ -36,8 +40,8 @@ X(0); X(1); X(2);
 
 <h3>2D and 3D repetition</h3>
 
-<p>2D and 3D repetition are supported with the BOOST_PP_REPEAT_2ND() and
-BOOST_PP_REPEAT_3RD() macros.</p>
+<p>BOOST_PP_REPEAT() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
 
 <h3>Example</h3>
 <ul>
@@ -48,142 +52,440 @@ BOOST_PP_REPEAT_3RD() macros.</p>
 <h3>See</h3>
 <ul>
   <li>BOOST_PP_FOR()</li>
+  <li>BOOST_PP_LIMIT_DIM</li>
   <li>BOOST_PP_LIMIT_MAG</li>
 </ul>
+
+<h3>Test</h3>
+<ul>
+  <li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
+  <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
+</ul>
 */
-#define BOOST_PP_REPEAT(COUNT,MACRO,DATA) BOOST_PP_REPEAT_DELAY(COUNT)(MACRO,DATA)
-
-#define BOOST_PP_REPEAT_DELAY(N) BOOST_PP_REPEAT##N
-#define BOOST_PP_REPEAT0(M,D)
-#define BOOST_PP_REPEAT1(M,D) M(0,D)
-#define BOOST_PP_REPEAT2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT5(M,D) BOOST_PP_REPEAT4(M,D) M(4,D)
-#define BOOST_PP_REPEAT6(M,D) BOOST_PP_REPEAT5(M,D) M(5,D)
-#define BOOST_PP_REPEAT7(M,D) BOOST_PP_REPEAT6(M,D) M(6,D)
-#define BOOST_PP_REPEAT8(M,D) BOOST_PP_REPEAT7(M,D) M(7,D)
-#define BOOST_PP_REPEAT9(M,D) BOOST_PP_REPEAT8(M,D) M(8,D)
-#define BOOST_PP_REPEAT10(M,D) BOOST_PP_REPEAT9(M,D) M(9,D)
-#define BOOST_PP_REPEAT11(M,D) BOOST_PP_REPEAT10(M,D) M(10,D)
-#define BOOST_PP_REPEAT12(M,D) BOOST_PP_REPEAT11(M,D) M(11,D)
-#define BOOST_PP_REPEAT13(M,D) BOOST_PP_REPEAT12(M,D) M(12,D)
-#define BOOST_PP_REPEAT14(M,D) BOOST_PP_REPEAT13(M,D) M(13,D)
-#define BOOST_PP_REPEAT15(M,D) BOOST_PP_REPEAT14(M,D) M(14,D)
-#define BOOST_PP_REPEAT16(M,D) BOOST_PP_REPEAT15(M,D) M(15,D)
-#define BOOST_PP_REPEAT17(M,D) BOOST_PP_REPEAT16(M,D) M(16,D)
-#define BOOST_PP_REPEAT18(M,D) BOOST_PP_REPEAT17(M,D) M(17,D)
-#define BOOST_PP_REPEAT19(M,D) BOOST_PP_REPEAT18(M,D) M(18,D)
-#define BOOST_PP_REPEAT20(M,D) BOOST_PP_REPEAT19(M,D) M(19,D)
-#define BOOST_PP_REPEAT21(M,D) BOOST_PP_REPEAT20(M,D) M(20,D)
-#define BOOST_PP_REPEAT22(M,D) BOOST_PP_REPEAT21(M,D) M(21,D)
-#define BOOST_PP_REPEAT23(M,D) BOOST_PP_REPEAT22(M,D) M(22,D)
-#define BOOST_PP_REPEAT24(M,D) BOOST_PP_REPEAT23(M,D) M(23,D)
-#define BOOST_PP_REPEAT25(M,D) BOOST_PP_REPEAT24(M,D) M(24,D)
-#define BOOST_PP_REPEAT26(M,D) BOOST_PP_REPEAT25(M,D) M(25,D)
-#define BOOST_PP_REPEAT27(M,D) BOOST_PP_REPEAT26(M,D) M(26,D)
-#define BOOST_PP_REPEAT28(M,D) BOOST_PP_REPEAT27(M,D) M(27,D)
-#define BOOST_PP_REPEAT29(M,D) BOOST_PP_REPEAT28(M,D) M(28,D)
-#define BOOST_PP_REPEAT30(M,D) BOOST_PP_REPEAT29(M,D) M(29,D)
-#define BOOST_PP_REPEAT31(M,D) BOOST_PP_REPEAT30(M,D) M(30,D)
-#define BOOST_PP_REPEAT32(M,D) BOOST_PP_REPEAT31(M,D) M(31,D)
-#define BOOST_PP_REPEAT33(M,D) BOOST_PP_REPEAT32(M,D) M(32,D)
-#define BOOST_PP_REPEAT34(M,D) BOOST_PP_REPEAT33(M,D) M(33,D)
-#define BOOST_PP_REPEAT35(M,D) BOOST_PP_REPEAT34(M,D) M(34,D)
-#define BOOST_PP_REPEAT36(M,D) BOOST_PP_REPEAT35(M,D) M(35,D)
-#define BOOST_PP_REPEAT37(M,D) BOOST_PP_REPEAT36(M,D) M(36,D)
-#define BOOST_PP_REPEAT38(M,D) BOOST_PP_REPEAT37(M,D) M(37,D)
-#define BOOST_PP_REPEAT39(M,D) BOOST_PP_REPEAT38(M,D) M(38,D)
-#define BOOST_PP_REPEAT40(M,D) BOOST_PP_REPEAT39(M,D) M(39,D)
-#define BOOST_PP_REPEAT41(M,D) BOOST_PP_REPEAT40(M,D) M(40,D)
-#define BOOST_PP_REPEAT42(M,D) BOOST_PP_REPEAT41(M,D) M(41,D)
-#define BOOST_PP_REPEAT43(M,D) BOOST_PP_REPEAT42(M,D) M(42,D)
-#define BOOST_PP_REPEAT44(M,D) BOOST_PP_REPEAT43(M,D) M(43,D)
-#define BOOST_PP_REPEAT45(M,D) BOOST_PP_REPEAT44(M,D) M(44,D)
-#define BOOST_PP_REPEAT46(M,D) BOOST_PP_REPEAT45(M,D) M(45,D)
-#define BOOST_PP_REPEAT47(M,D) BOOST_PP_REPEAT46(M,D) M(46,D)
-#define BOOST_PP_REPEAT48(M,D) BOOST_PP_REPEAT47(M,D) M(47,D)
-#define BOOST_PP_REPEAT49(M,D) BOOST_PP_REPEAT48(M,D) M(48,D)
-#define BOOST_PP_REPEAT50(M,D) BOOST_PP_REPEAT49(M,D) M(49,D)
-#define BOOST_PP_REPEAT51(M,D) BOOST_PP_REPEAT50(M,D) M(50,D)
-#define BOOST_PP_REPEAT52(M,D) BOOST_PP_REPEAT51(M,D) M(51,D)
-#define BOOST_PP_REPEAT53(M,D) BOOST_PP_REPEAT52(M,D) M(52,D)
-#define BOOST_PP_REPEAT54(M,D) BOOST_PP_REPEAT53(M,D) M(53,D)
-#define BOOST_PP_REPEAT55(M,D) BOOST_PP_REPEAT54(M,D) M(54,D)
-#define BOOST_PP_REPEAT56(M,D) BOOST_PP_REPEAT55(M,D) M(55,D)
-#define BOOST_PP_REPEAT57(M,D) BOOST_PP_REPEAT56(M,D) M(56,D)
-#define BOOST_PP_REPEAT58(M,D) BOOST_PP_REPEAT57(M,D) M(57,D)
-#define BOOST_PP_REPEAT59(M,D) BOOST_PP_REPEAT58(M,D) M(58,D)
-#define BOOST_PP_REPEAT60(M,D) BOOST_PP_REPEAT59(M,D) M(59,D)
-#define BOOST_PP_REPEAT61(M,D) BOOST_PP_REPEAT60(M,D) M(60,D)
-#define BOOST_PP_REPEAT62(M,D) BOOST_PP_REPEAT61(M,D) M(61,D)
-#define BOOST_PP_REPEAT63(M,D) BOOST_PP_REPEAT62(M,D) M(62,D)
-#define BOOST_PP_REPEAT64(M,D) BOOST_PP_REPEAT63(M,D) M(63,D)
-#define BOOST_PP_REPEAT65(M,D) BOOST_PP_REPEAT64(M,D) M(64,D)
-#define BOOST_PP_REPEAT66(M,D) BOOST_PP_REPEAT65(M,D) M(65,D)
-#define BOOST_PP_REPEAT67(M,D) BOOST_PP_REPEAT66(M,D) M(66,D)
-#define BOOST_PP_REPEAT68(M,D) BOOST_PP_REPEAT67(M,D) M(67,D)
-#define BOOST_PP_REPEAT69(M,D) BOOST_PP_REPEAT68(M,D) M(68,D)
-#define BOOST_PP_REPEAT70(M,D) BOOST_PP_REPEAT69(M,D) M(69,D)
-#define BOOST_PP_REPEAT71(M,D) BOOST_PP_REPEAT70(M,D) M(70,D)
-#define BOOST_PP_REPEAT72(M,D) BOOST_PP_REPEAT71(M,D) M(71,D)
-#define BOOST_PP_REPEAT73(M,D) BOOST_PP_REPEAT72(M,D) M(72,D)
-#define BOOST_PP_REPEAT74(M,D) BOOST_PP_REPEAT73(M,D) M(73,D)
-#define BOOST_PP_REPEAT75(M,D) BOOST_PP_REPEAT74(M,D) M(74,D)
-#define BOOST_PP_REPEAT76(M,D) BOOST_PP_REPEAT75(M,D) M(75,D)
-#define BOOST_PP_REPEAT77(M,D) BOOST_PP_REPEAT76(M,D) M(76,D)
-#define BOOST_PP_REPEAT78(M,D) BOOST_PP_REPEAT77(M,D) M(77,D)
-#define BOOST_PP_REPEAT79(M,D) BOOST_PP_REPEAT78(M,D) M(78,D)
-#define BOOST_PP_REPEAT80(M,D) BOOST_PP_REPEAT79(M,D) M(79,D)
-#define BOOST_PP_REPEAT81(M,D) BOOST_PP_REPEAT80(M,D) M(80,D)
-#define BOOST_PP_REPEAT82(M,D) BOOST_PP_REPEAT81(M,D) M(81,D)
-#define BOOST_PP_REPEAT83(M,D) BOOST_PP_REPEAT82(M,D) M(82,D)
-#define BOOST_PP_REPEAT84(M,D) BOOST_PP_REPEAT83(M,D) M(83,D)
-#define BOOST_PP_REPEAT85(M,D) BOOST_PP_REPEAT84(M,D) M(84,D)
-#define BOOST_PP_REPEAT86(M,D) BOOST_PP_REPEAT85(M,D) M(85,D)
-#define BOOST_PP_REPEAT87(M,D) BOOST_PP_REPEAT86(M,D) M(86,D)
-#define BOOST_PP_REPEAT88(M,D) BOOST_PP_REPEAT87(M,D) M(87,D)
-#define BOOST_PP_REPEAT89(M,D) BOOST_PP_REPEAT88(M,D) M(88,D)
-#define BOOST_PP_REPEAT90(M,D) BOOST_PP_REPEAT89(M,D) M(89,D)
-#define BOOST_PP_REPEAT91(M,D) BOOST_PP_REPEAT90(M,D) M(90,D)
-#define BOOST_PP_REPEAT92(M,D) BOOST_PP_REPEAT91(M,D) M(91,D)
-#define BOOST_PP_REPEAT93(M,D) BOOST_PP_REPEAT92(M,D) M(92,D)
-#define BOOST_PP_REPEAT94(M,D) BOOST_PP_REPEAT93(M,D) M(93,D)
-#define BOOST_PP_REPEAT95(M,D) BOOST_PP_REPEAT94(M,D) M(94,D)
-#define BOOST_PP_REPEAT96(M,D) BOOST_PP_REPEAT95(M,D) M(95,D)
-#define BOOST_PP_REPEAT97(M,D) BOOST_PP_REPEAT96(M,D) M(96,D)
-#define BOOST_PP_REPEAT98(M,D) BOOST_PP_REPEAT97(M,D) M(97,D)
-#define BOOST_PP_REPEAT99(M,D) BOOST_PP_REPEAT98(M,D) M(98,D)
-#define BOOST_PP_REPEAT100(M,D) BOOST_PP_REPEAT99(M,D) M(99,D)
-#define BOOST_PP_REPEAT101(M,D) BOOST_PP_REPEAT100(M,D) M(100,D)
-#define BOOST_PP_REPEAT102(M,D) BOOST_PP_REPEAT101(M,D) M(101,D)
-#define BOOST_PP_REPEAT103(M,D) BOOST_PP_REPEAT102(M,D) M(102,D)
-#define BOOST_PP_REPEAT104(M,D) BOOST_PP_REPEAT103(M,D) M(103,D)
-#define BOOST_PP_REPEAT105(M,D) BOOST_PP_REPEAT104(M,D) M(104,D)
-#define BOOST_PP_REPEAT106(M,D) BOOST_PP_REPEAT105(M,D) M(105,D)
-#define BOOST_PP_REPEAT107(M,D) BOOST_PP_REPEAT106(M,D) M(106,D)
-#define BOOST_PP_REPEAT108(M,D) BOOST_PP_REPEAT107(M,D) M(107,D)
-#define BOOST_PP_REPEAT109(M,D) BOOST_PP_REPEAT108(M,D) M(108,D)
-#define BOOST_PP_REPEAT110(M,D) BOOST_PP_REPEAT109(M,D) M(109,D)
-#define BOOST_PP_REPEAT111(M,D) BOOST_PP_REPEAT110(M,D) M(110,D)
-#define BOOST_PP_REPEAT112(M,D) BOOST_PP_REPEAT111(M,D) M(111,D)
-#define BOOST_PP_REPEAT113(M,D) BOOST_PP_REPEAT112(M,D) M(112,D)
-#define BOOST_PP_REPEAT114(M,D) BOOST_PP_REPEAT113(M,D) M(113,D)
-#define BOOST_PP_REPEAT115(M,D) BOOST_PP_REPEAT114(M,D) M(114,D)
-#define BOOST_PP_REPEAT116(M,D) BOOST_PP_REPEAT115(M,D) M(115,D)
-#define BOOST_PP_REPEAT117(M,D) BOOST_PP_REPEAT116(M,D) M(116,D)
-#define BOOST_PP_REPEAT118(M,D) BOOST_PP_REPEAT117(M,D) M(117,D)
-#define BOOST_PP_REPEAT119(M,D) BOOST_PP_REPEAT118(M,D) M(118,D)
-#define BOOST_PP_REPEAT120(M,D) BOOST_PP_REPEAT119(M,D) M(119,D)
-#define BOOST_PP_REPEAT121(M,D) BOOST_PP_REPEAT120(M,D) M(120,D)
-#define BOOST_PP_REPEAT122(M,D) BOOST_PP_REPEAT121(M,D) M(121,D)
-#define BOOST_PP_REPEAT123(M,D) BOOST_PP_REPEAT122(M,D) M(122,D)
-#define BOOST_PP_REPEAT124(M,D) BOOST_PP_REPEAT123(M,D) M(123,D)
-#define BOOST_PP_REPEAT125(M,D) BOOST_PP_REPEAT124(M,D) M(124,D)
-#define BOOST_PP_REPEAT126(M,D) BOOST_PP_REPEAT125(M,D) M(125,D)
-#define BOOST_PP_REPEAT127(M,D) BOOST_PP_REPEAT126(M,D) M(126,D)
-#define BOOST_PP_REPEAT128(M,D) BOOST_PP_REPEAT127(M,D) M(127,D)
-
-/* <p>Obsolete. Use BOOST_PP_REPEAT().</p> */
-#define BOOST_PREPROCESSOR_REPEAT(C,M,D) BOOST_PP_REPEAT(C,M,D)
+#if 0
+#  define BOOST_PP_REPEAT(COUNT,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_REPEAT_AUTO_REC3/4/etc. wrapping as the maximum level of 
+ * nesting REPEATS increases
+ */
+#  define BOOST_PP_REPEAT\
+     BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC2(\
+       BOOST_PP_REPEAT_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+       ))
+#else
+#  define BOOST_PP_REPEAT\
+    BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#endif
+
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC1(M,P)\
+  BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC2(M,P)\
+  BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#define BOOST_PP_REPEAT_BOOST_PP_REPEAT_AUTO_REC3(M,P)\
+  (TOO MANY NESTED REPEATS!)
+
+#define BOOST_PP_REPEAT_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_REPEAT_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#define BOOST_PP_REPEAT_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#define BOOST_PP_REPEAT_1(C,M,D) BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_DETAIL_CAT2(BOOST_PP_R1_,C),(M,D))
+#define BOOST_PP_R1_0(M,D)
+#define BOOST_PP_R1_1(M,D) M(0,D)
+#define BOOST_PP_R1_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R1_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R1_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R1_5(M,D) BOOST_PP_R1_4(M,D) M(4,D)
+#define BOOST_PP_R1_6(M,D) BOOST_PP_R1_5(M,D) M(5,D)
+#define BOOST_PP_R1_7(M,D) BOOST_PP_R1_6(M,D) M(6,D)
+#define BOOST_PP_R1_8(M,D) BOOST_PP_R1_7(M,D) M(7,D)
+#define BOOST_PP_R1_9(M,D) BOOST_PP_R1_8(M,D) M(8,D)
+#define BOOST_PP_R1_10(M,D) BOOST_PP_R1_9(M,D) M(9,D)
+#define BOOST_PP_R1_11(M,D) BOOST_PP_R1_10(M,D) M(10,D)
+#define BOOST_PP_R1_12(M,D) BOOST_PP_R1_11(M,D) M(11,D)
+#define BOOST_PP_R1_13(M,D) BOOST_PP_R1_12(M,D) M(12,D)
+#define BOOST_PP_R1_14(M,D) BOOST_PP_R1_13(M,D) M(13,D)
+#define BOOST_PP_R1_15(M,D) BOOST_PP_R1_14(M,D) M(14,D)
+#define BOOST_PP_R1_16(M,D) BOOST_PP_R1_15(M,D) M(15,D)
+#define BOOST_PP_R1_17(M,D) BOOST_PP_R1_16(M,D) M(16,D)
+#define BOOST_PP_R1_18(M,D) BOOST_PP_R1_17(M,D) M(17,D)
+#define BOOST_PP_R1_19(M,D) BOOST_PP_R1_18(M,D) M(18,D)
+#define BOOST_PP_R1_20(M,D) BOOST_PP_R1_19(M,D) M(19,D)
+#define BOOST_PP_R1_21(M,D) BOOST_PP_R1_20(M,D) M(20,D)
+#define BOOST_PP_R1_22(M,D) BOOST_PP_R1_21(M,D) M(21,D)
+#define BOOST_PP_R1_23(M,D) BOOST_PP_R1_22(M,D) M(22,D)
+#define BOOST_PP_R1_24(M,D) BOOST_PP_R1_23(M,D) M(23,D)
+#define BOOST_PP_R1_25(M,D) BOOST_PP_R1_24(M,D) M(24,D)
+#define BOOST_PP_R1_26(M,D) BOOST_PP_R1_25(M,D) M(25,D)
+#define BOOST_PP_R1_27(M,D) BOOST_PP_R1_26(M,D) M(26,D)
+#define BOOST_PP_R1_28(M,D) BOOST_PP_R1_27(M,D) M(27,D)
+#define BOOST_PP_R1_29(M,D) BOOST_PP_R1_28(M,D) M(28,D)
+#define BOOST_PP_R1_30(M,D) BOOST_PP_R1_29(M,D) M(29,D)
+#define BOOST_PP_R1_31(M,D) BOOST_PP_R1_30(M,D) M(30,D)
+#define BOOST_PP_R1_32(M,D) BOOST_PP_R1_31(M,D) M(31,D)
+#define BOOST_PP_R1_33(M,D) BOOST_PP_R1_32(M,D) M(32,D)
+#define BOOST_PP_R1_34(M,D) BOOST_PP_R1_33(M,D) M(33,D)
+#define BOOST_PP_R1_35(M,D) BOOST_PP_R1_34(M,D) M(34,D)
+#define BOOST_PP_R1_36(M,D) BOOST_PP_R1_35(M,D) M(35,D)
+#define BOOST_PP_R1_37(M,D) BOOST_PP_R1_36(M,D) M(36,D)
+#define BOOST_PP_R1_38(M,D) BOOST_PP_R1_37(M,D) M(37,D)
+#define BOOST_PP_R1_39(M,D) BOOST_PP_R1_38(M,D) M(38,D)
+#define BOOST_PP_R1_40(M,D) BOOST_PP_R1_39(M,D) M(39,D)
+#define BOOST_PP_R1_41(M,D) BOOST_PP_R1_40(M,D) M(40,D)
+#define BOOST_PP_R1_42(M,D) BOOST_PP_R1_41(M,D) M(41,D)
+#define BOOST_PP_R1_43(M,D) BOOST_PP_R1_42(M,D) M(42,D)
+#define BOOST_PP_R1_44(M,D) BOOST_PP_R1_43(M,D) M(43,D)
+#define BOOST_PP_R1_45(M,D) BOOST_PP_R1_44(M,D) M(44,D)
+#define BOOST_PP_R1_46(M,D) BOOST_PP_R1_45(M,D) M(45,D)
+#define BOOST_PP_R1_47(M,D) BOOST_PP_R1_46(M,D) M(46,D)
+#define BOOST_PP_R1_48(M,D) BOOST_PP_R1_47(M,D) M(47,D)
+#define BOOST_PP_R1_49(M,D) BOOST_PP_R1_48(M,D) M(48,D)
+#define BOOST_PP_R1_50(M,D) BOOST_PP_R1_49(M,D) M(49,D)
+#define BOOST_PP_R1_51(M,D) BOOST_PP_R1_50(M,D) M(50,D)
+#define BOOST_PP_R1_52(M,D) BOOST_PP_R1_51(M,D) M(51,D)
+#define BOOST_PP_R1_53(M,D) BOOST_PP_R1_52(M,D) M(52,D)
+#define BOOST_PP_R1_54(M,D) BOOST_PP_R1_53(M,D) M(53,D)
+#define BOOST_PP_R1_55(M,D) BOOST_PP_R1_54(M,D) M(54,D)
+#define BOOST_PP_R1_56(M,D) BOOST_PP_R1_55(M,D) M(55,D)
+#define BOOST_PP_R1_57(M,D) BOOST_PP_R1_56(M,D) M(56,D)
+#define BOOST_PP_R1_58(M,D) BOOST_PP_R1_57(M,D) M(57,D)
+#define BOOST_PP_R1_59(M,D) BOOST_PP_R1_58(M,D) M(58,D)
+#define BOOST_PP_R1_60(M,D) BOOST_PP_R1_59(M,D) M(59,D)
+#define BOOST_PP_R1_61(M,D) BOOST_PP_R1_60(M,D) M(60,D)
+#define BOOST_PP_R1_62(M,D) BOOST_PP_R1_61(M,D) M(61,D)
+#define BOOST_PP_R1_63(M,D) BOOST_PP_R1_62(M,D) M(62,D)
+#define BOOST_PP_R1_64(M,D) BOOST_PP_R1_63(M,D) M(63,D)
+#define BOOST_PP_R1_65(M,D) BOOST_PP_R1_64(M,D) M(64,D)
+#define BOOST_PP_R1_66(M,D) BOOST_PP_R1_65(M,D) M(65,D)
+#define BOOST_PP_R1_67(M,D) BOOST_PP_R1_66(M,D) M(66,D)
+#define BOOST_PP_R1_68(M,D) BOOST_PP_R1_67(M,D) M(67,D)
+#define BOOST_PP_R1_69(M,D) BOOST_PP_R1_68(M,D) M(68,D)
+#define BOOST_PP_R1_70(M,D) BOOST_PP_R1_69(M,D) M(69,D)
+#define BOOST_PP_R1_71(M,D) BOOST_PP_R1_70(M,D) M(70,D)
+#define BOOST_PP_R1_72(M,D) BOOST_PP_R1_71(M,D) M(71,D)
+#define BOOST_PP_R1_73(M,D) BOOST_PP_R1_72(M,D) M(72,D)
+#define BOOST_PP_R1_74(M,D) BOOST_PP_R1_73(M,D) M(73,D)
+#define BOOST_PP_R1_75(M,D) BOOST_PP_R1_74(M,D) M(74,D)
+#define BOOST_PP_R1_76(M,D) BOOST_PP_R1_75(M,D) M(75,D)
+#define BOOST_PP_R1_77(M,D) BOOST_PP_R1_76(M,D) M(76,D)
+#define BOOST_PP_R1_78(M,D) BOOST_PP_R1_77(M,D) M(77,D)
+#define BOOST_PP_R1_79(M,D) BOOST_PP_R1_78(M,D) M(78,D)
+#define BOOST_PP_R1_80(M,D) BOOST_PP_R1_79(M,D) M(79,D)
+#define BOOST_PP_R1_81(M,D) BOOST_PP_R1_80(M,D) M(80,D)
+#define BOOST_PP_R1_82(M,D) BOOST_PP_R1_81(M,D) M(81,D)
+#define BOOST_PP_R1_83(M,D) BOOST_PP_R1_82(M,D) M(82,D)
+#define BOOST_PP_R1_84(M,D) BOOST_PP_R1_83(M,D) M(83,D)
+#define BOOST_PP_R1_85(M,D) BOOST_PP_R1_84(M,D) M(84,D)
+#define BOOST_PP_R1_86(M,D) BOOST_PP_R1_85(M,D) M(85,D)
+#define BOOST_PP_R1_87(M,D) BOOST_PP_R1_86(M,D) M(86,D)
+#define BOOST_PP_R1_88(M,D) BOOST_PP_R1_87(M,D) M(87,D)
+#define BOOST_PP_R1_89(M,D) BOOST_PP_R1_88(M,D) M(88,D)
+#define BOOST_PP_R1_90(M,D) BOOST_PP_R1_89(M,D) M(89,D)
+#define BOOST_PP_R1_91(M,D) BOOST_PP_R1_90(M,D) M(90,D)
+#define BOOST_PP_R1_92(M,D) BOOST_PP_R1_91(M,D) M(91,D)
+#define BOOST_PP_R1_93(M,D) BOOST_PP_R1_92(M,D) M(92,D)
+#define BOOST_PP_R1_94(M,D) BOOST_PP_R1_93(M,D) M(93,D)
+#define BOOST_PP_R1_95(M,D) BOOST_PP_R1_94(M,D) M(94,D)
+#define BOOST_PP_R1_96(M,D) BOOST_PP_R1_95(M,D) M(95,D)
+#define BOOST_PP_R1_97(M,D) BOOST_PP_R1_96(M,D) M(96,D)
+#define BOOST_PP_R1_98(M,D) BOOST_PP_R1_97(M,D) M(97,D)
+#define BOOST_PP_R1_99(M,D) BOOST_PP_R1_98(M,D) M(98,D)
+#define BOOST_PP_R1_100(M,D) BOOST_PP_R1_99(M,D) M(99,D)
+#define BOOST_PP_R1_101(M,D) BOOST_PP_R1_100(M,D) M(100,D)
+#define BOOST_PP_R1_102(M,D) BOOST_PP_R1_101(M,D) M(101,D)
+#define BOOST_PP_R1_103(M,D) BOOST_PP_R1_102(M,D) M(102,D)
+#define BOOST_PP_R1_104(M,D) BOOST_PP_R1_103(M,D) M(103,D)
+#define BOOST_PP_R1_105(M,D) BOOST_PP_R1_104(M,D) M(104,D)
+#define BOOST_PP_R1_106(M,D) BOOST_PP_R1_105(M,D) M(105,D)
+#define BOOST_PP_R1_107(M,D) BOOST_PP_R1_106(M,D) M(106,D)
+#define BOOST_PP_R1_108(M,D) BOOST_PP_R1_107(M,D) M(107,D)
+#define BOOST_PP_R1_109(M,D) BOOST_PP_R1_108(M,D) M(108,D)
+#define BOOST_PP_R1_110(M,D) BOOST_PP_R1_109(M,D) M(109,D)
+#define BOOST_PP_R1_111(M,D) BOOST_PP_R1_110(M,D) M(110,D)
+#define BOOST_PP_R1_112(M,D) BOOST_PP_R1_111(M,D) M(111,D)
+#define BOOST_PP_R1_113(M,D) BOOST_PP_R1_112(M,D) M(112,D)
+#define BOOST_PP_R1_114(M,D) BOOST_PP_R1_113(M,D) M(113,D)
+#define BOOST_PP_R1_115(M,D) BOOST_PP_R1_114(M,D) M(114,D)
+#define BOOST_PP_R1_116(M,D) BOOST_PP_R1_115(M,D) M(115,D)
+#define BOOST_PP_R1_117(M,D) BOOST_PP_R1_116(M,D) M(116,D)
+#define BOOST_PP_R1_118(M,D) BOOST_PP_R1_117(M,D) M(117,D)
+#define BOOST_PP_R1_119(M,D) BOOST_PP_R1_118(M,D) M(118,D)
+#define BOOST_PP_R1_120(M,D) BOOST_PP_R1_119(M,D) M(119,D)
+#define BOOST_PP_R1_121(M,D) BOOST_PP_R1_120(M,D) M(120,D)
+#define BOOST_PP_R1_122(M,D) BOOST_PP_R1_121(M,D) M(121,D)
+#define BOOST_PP_R1_123(M,D) BOOST_PP_R1_122(M,D) M(122,D)
+#define BOOST_PP_R1_124(M,D) BOOST_PP_R1_123(M,D) M(123,D)
+#define BOOST_PP_R1_125(M,D) BOOST_PP_R1_124(M,D) M(124,D)
+#define BOOST_PP_R1_126(M,D) BOOST_PP_R1_125(M,D) M(125,D)
+#define BOOST_PP_R1_127(M,D) BOOST_PP_R1_126(M,D) M(126,D)
+#define BOOST_PP_R1_128(M,D) BOOST_PP_R1_127(M,D) M(127,D)
+
+#define BOOST_PP_REPEAT_2(C,M,D) BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_DETAIL_CAT2(BOOST_PP_R2_,C),(M,D))
+#define BOOST_PP_R2_0(M,D)
+#define BOOST_PP_R2_1(M,D) M(0,D)
+#define BOOST_PP_R2_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R2_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R2_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R2_5(M,D) BOOST_PP_R2_4(M,D) M(4,D)
+#define BOOST_PP_R2_6(M,D) BOOST_PP_R2_5(M,D) M(5,D)
+#define BOOST_PP_R2_7(M,D) BOOST_PP_R2_6(M,D) M(6,D)
+#define BOOST_PP_R2_8(M,D) BOOST_PP_R2_7(M,D) M(7,D)
+#define BOOST_PP_R2_9(M,D) BOOST_PP_R2_8(M,D) M(8,D)
+#define BOOST_PP_R2_10(M,D) BOOST_PP_R2_9(M,D) M(9,D)
+#define BOOST_PP_R2_11(M,D) BOOST_PP_R2_10(M,D) M(10,D)
+#define BOOST_PP_R2_12(M,D) BOOST_PP_R2_11(M,D) M(11,D)
+#define BOOST_PP_R2_13(M,D) BOOST_PP_R2_12(M,D) M(12,D)
+#define BOOST_PP_R2_14(M,D) BOOST_PP_R2_13(M,D) M(13,D)
+#define BOOST_PP_R2_15(M,D) BOOST_PP_R2_14(M,D) M(14,D)
+#define BOOST_PP_R2_16(M,D) BOOST_PP_R2_15(M,D) M(15,D)
+#define BOOST_PP_R2_17(M,D) BOOST_PP_R2_16(M,D) M(16,D)
+#define BOOST_PP_R2_18(M,D) BOOST_PP_R2_17(M,D) M(17,D)
+#define BOOST_PP_R2_19(M,D) BOOST_PP_R2_18(M,D) M(18,D)
+#define BOOST_PP_R2_20(M,D) BOOST_PP_R2_19(M,D) M(19,D)
+#define BOOST_PP_R2_21(M,D) BOOST_PP_R2_20(M,D) M(20,D)
+#define BOOST_PP_R2_22(M,D) BOOST_PP_R2_21(M,D) M(21,D)
+#define BOOST_PP_R2_23(M,D) BOOST_PP_R2_22(M,D) M(22,D)
+#define BOOST_PP_R2_24(M,D) BOOST_PP_R2_23(M,D) M(23,D)
+#define BOOST_PP_R2_25(M,D) BOOST_PP_R2_24(M,D) M(24,D)
+#define BOOST_PP_R2_26(M,D) BOOST_PP_R2_25(M,D) M(25,D)
+#define BOOST_PP_R2_27(M,D) BOOST_PP_R2_26(M,D) M(26,D)
+#define BOOST_PP_R2_28(M,D) BOOST_PP_R2_27(M,D) M(27,D)
+#define BOOST_PP_R2_29(M,D) BOOST_PP_R2_28(M,D) M(28,D)
+#define BOOST_PP_R2_30(M,D) BOOST_PP_R2_29(M,D) M(29,D)
+#define BOOST_PP_R2_31(M,D) BOOST_PP_R2_30(M,D) M(30,D)
+#define BOOST_PP_R2_32(M,D) BOOST_PP_R2_31(M,D) M(31,D)
+#define BOOST_PP_R2_33(M,D) BOOST_PP_R2_32(M,D) M(32,D)
+#define BOOST_PP_R2_34(M,D) BOOST_PP_R2_33(M,D) M(33,D)
+#define BOOST_PP_R2_35(M,D) BOOST_PP_R2_34(M,D) M(34,D)
+#define BOOST_PP_R2_36(M,D) BOOST_PP_R2_35(M,D) M(35,D)
+#define BOOST_PP_R2_37(M,D) BOOST_PP_R2_36(M,D) M(36,D)
+#define BOOST_PP_R2_38(M,D) BOOST_PP_R2_37(M,D) M(37,D)
+#define BOOST_PP_R2_39(M,D) BOOST_PP_R2_38(M,D) M(38,D)
+#define BOOST_PP_R2_40(M,D) BOOST_PP_R2_39(M,D) M(39,D)
+#define BOOST_PP_R2_41(M,D) BOOST_PP_R2_40(M,D) M(40,D)
+#define BOOST_PP_R2_42(M,D) BOOST_PP_R2_41(M,D) M(41,D)
+#define BOOST_PP_R2_43(M,D) BOOST_PP_R2_42(M,D) M(42,D)
+#define BOOST_PP_R2_44(M,D) BOOST_PP_R2_43(M,D) M(43,D)
+#define BOOST_PP_R2_45(M,D) BOOST_PP_R2_44(M,D) M(44,D)
+#define BOOST_PP_R2_46(M,D) BOOST_PP_R2_45(M,D) M(45,D)
+#define BOOST_PP_R2_47(M,D) BOOST_PP_R2_46(M,D) M(46,D)
+#define BOOST_PP_R2_48(M,D) BOOST_PP_R2_47(M,D) M(47,D)
+#define BOOST_PP_R2_49(M,D) BOOST_PP_R2_48(M,D) M(48,D)
+#define BOOST_PP_R2_50(M,D) BOOST_PP_R2_49(M,D) M(49,D)
+#define BOOST_PP_R2_51(M,D) BOOST_PP_R2_50(M,D) M(50,D)
+#define BOOST_PP_R2_52(M,D) BOOST_PP_R2_51(M,D) M(51,D)
+#define BOOST_PP_R2_53(M,D) BOOST_PP_R2_52(M,D) M(52,D)
+#define BOOST_PP_R2_54(M,D) BOOST_PP_R2_53(M,D) M(53,D)
+#define BOOST_PP_R2_55(M,D) BOOST_PP_R2_54(M,D) M(54,D)
+#define BOOST_PP_R2_56(M,D) BOOST_PP_R2_55(M,D) M(55,D)
+#define BOOST_PP_R2_57(M,D) BOOST_PP_R2_56(M,D) M(56,D)
+#define BOOST_PP_R2_58(M,D) BOOST_PP_R2_57(M,D) M(57,D)
+#define BOOST_PP_R2_59(M,D) BOOST_PP_R2_58(M,D) M(58,D)
+#define BOOST_PP_R2_60(M,D) BOOST_PP_R2_59(M,D) M(59,D)
+#define BOOST_PP_R2_61(M,D) BOOST_PP_R2_60(M,D) M(60,D)
+#define BOOST_PP_R2_62(M,D) BOOST_PP_R2_61(M,D) M(61,D)
+#define BOOST_PP_R2_63(M,D) BOOST_PP_R2_62(M,D) M(62,D)
+#define BOOST_PP_R2_64(M,D) BOOST_PP_R2_63(M,D) M(63,D)
+#define BOOST_PP_R2_65(M,D) BOOST_PP_R2_64(M,D) M(64,D)
+#define BOOST_PP_R2_66(M,D) BOOST_PP_R2_65(M,D) M(65,D)
+#define BOOST_PP_R2_67(M,D) BOOST_PP_R2_66(M,D) M(66,D)
+#define BOOST_PP_R2_68(M,D) BOOST_PP_R2_67(M,D) M(67,D)
+#define BOOST_PP_R2_69(M,D) BOOST_PP_R2_68(M,D) M(68,D)
+#define BOOST_PP_R2_70(M,D) BOOST_PP_R2_69(M,D) M(69,D)
+#define BOOST_PP_R2_71(M,D) BOOST_PP_R2_70(M,D) M(70,D)
+#define BOOST_PP_R2_72(M,D) BOOST_PP_R2_71(M,D) M(71,D)
+#define BOOST_PP_R2_73(M,D) BOOST_PP_R2_72(M,D) M(72,D)
+#define BOOST_PP_R2_74(M,D) BOOST_PP_R2_73(M,D) M(73,D)
+#define BOOST_PP_R2_75(M,D) BOOST_PP_R2_74(M,D) M(74,D)
+#define BOOST_PP_R2_76(M,D) BOOST_PP_R2_75(M,D) M(75,D)
+#define BOOST_PP_R2_77(M,D) BOOST_PP_R2_76(M,D) M(76,D)
+#define BOOST_PP_R2_78(M,D) BOOST_PP_R2_77(M,D) M(77,D)
+#define BOOST_PP_R2_79(M,D) BOOST_PP_R2_78(M,D) M(78,D)
+#define BOOST_PP_R2_80(M,D) BOOST_PP_R2_79(M,D) M(79,D)
+#define BOOST_PP_R2_81(M,D) BOOST_PP_R2_80(M,D) M(80,D)
+#define BOOST_PP_R2_82(M,D) BOOST_PP_R2_81(M,D) M(81,D)
+#define BOOST_PP_R2_83(M,D) BOOST_PP_R2_82(M,D) M(82,D)
+#define BOOST_PP_R2_84(M,D) BOOST_PP_R2_83(M,D) M(83,D)
+#define BOOST_PP_R2_85(M,D) BOOST_PP_R2_84(M,D) M(84,D)
+#define BOOST_PP_R2_86(M,D) BOOST_PP_R2_85(M,D) M(85,D)
+#define BOOST_PP_R2_87(M,D) BOOST_PP_R2_86(M,D) M(86,D)
+#define BOOST_PP_R2_88(M,D) BOOST_PP_R2_87(M,D) M(87,D)
+#define BOOST_PP_R2_89(M,D) BOOST_PP_R2_88(M,D) M(88,D)
+#define BOOST_PP_R2_90(M,D) BOOST_PP_R2_89(M,D) M(89,D)
+#define BOOST_PP_R2_91(M,D) BOOST_PP_R2_90(M,D) M(90,D)
+#define BOOST_PP_R2_92(M,D) BOOST_PP_R2_91(M,D) M(91,D)
+#define BOOST_PP_R2_93(M,D) BOOST_PP_R2_92(M,D) M(92,D)
+#define BOOST_PP_R2_94(M,D) BOOST_PP_R2_93(M,D) M(93,D)
+#define BOOST_PP_R2_95(M,D) BOOST_PP_R2_94(M,D) M(94,D)
+#define BOOST_PP_R2_96(M,D) BOOST_PP_R2_95(M,D) M(95,D)
+#define BOOST_PP_R2_97(M,D) BOOST_PP_R2_96(M,D) M(96,D)
+#define BOOST_PP_R2_98(M,D) BOOST_PP_R2_97(M,D) M(97,D)
+#define BOOST_PP_R2_99(M,D) BOOST_PP_R2_98(M,D) M(98,D)
+#define BOOST_PP_R2_100(M,D) BOOST_PP_R2_99(M,D) M(99,D)
+#define BOOST_PP_R2_101(M,D) BOOST_PP_R2_100(M,D) M(100,D)
+#define BOOST_PP_R2_102(M,D) BOOST_PP_R2_101(M,D) M(101,D)
+#define BOOST_PP_R2_103(M,D) BOOST_PP_R2_102(M,D) M(102,D)
+#define BOOST_PP_R2_104(M,D) BOOST_PP_R2_103(M,D) M(103,D)
+#define BOOST_PP_R2_105(M,D) BOOST_PP_R2_104(M,D) M(104,D)
+#define BOOST_PP_R2_106(M,D) BOOST_PP_R2_105(M,D) M(105,D)
+#define BOOST_PP_R2_107(M,D) BOOST_PP_R2_106(M,D) M(106,D)
+#define BOOST_PP_R2_108(M,D) BOOST_PP_R2_107(M,D) M(107,D)
+#define BOOST_PP_R2_109(M,D) BOOST_PP_R2_108(M,D) M(108,D)
+#define BOOST_PP_R2_110(M,D) BOOST_PP_R2_109(M,D) M(109,D)
+#define BOOST_PP_R2_111(M,D) BOOST_PP_R2_110(M,D) M(110,D)
+#define BOOST_PP_R2_112(M,D) BOOST_PP_R2_111(M,D) M(111,D)
+#define BOOST_PP_R2_113(M,D) BOOST_PP_R2_112(M,D) M(112,D)
+#define BOOST_PP_R2_114(M,D) BOOST_PP_R2_113(M,D) M(113,D)
+#define BOOST_PP_R2_115(M,D) BOOST_PP_R2_114(M,D) M(114,D)
+#define BOOST_PP_R2_116(M,D) BOOST_PP_R2_115(M,D) M(115,D)
+#define BOOST_PP_R2_117(M,D) BOOST_PP_R2_116(M,D) M(116,D)
+#define BOOST_PP_R2_118(M,D) BOOST_PP_R2_117(M,D) M(117,D)
+#define BOOST_PP_R2_119(M,D) BOOST_PP_R2_118(M,D) M(118,D)
+#define BOOST_PP_R2_120(M,D) BOOST_PP_R2_119(M,D) M(119,D)
+#define BOOST_PP_R2_121(M,D) BOOST_PP_R2_120(M,D) M(120,D)
+#define BOOST_PP_R2_122(M,D) BOOST_PP_R2_121(M,D) M(121,D)
+#define BOOST_PP_R2_123(M,D) BOOST_PP_R2_122(M,D) M(122,D)
+#define BOOST_PP_R2_124(M,D) BOOST_PP_R2_123(M,D) M(123,D)
+#define BOOST_PP_R2_125(M,D) BOOST_PP_R2_124(M,D) M(124,D)
+#define BOOST_PP_R2_126(M,D) BOOST_PP_R2_125(M,D) M(125,D)
+#define BOOST_PP_R2_127(M,D) BOOST_PP_R2_126(M,D) M(126,D)
+#define BOOST_PP_R2_128(M,D) BOOST_PP_R2_127(M,D) M(127,D)
+
+#define BOOST_PP_REPEAT_3(C,M,D) BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_DETAIL_CAT2(BOOST_PP_R3_,C),(M,D))
+#define BOOST_PP_R3_0(M,D)
+#define BOOST_PP_R3_1(M,D) M(0,D)
+#define BOOST_PP_R3_2(M,D) M(0,D) M(1,D)
+#define BOOST_PP_R3_3(M,D) M(0,D) M(1,D) M(2,D)
+#define BOOST_PP_R3_4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
+#define BOOST_PP_R3_5(M,D) BOOST_PP_R3_4(M,D) M(4,D)
+#define BOOST_PP_R3_6(M,D) BOOST_PP_R3_5(M,D) M(5,D)
+#define BOOST_PP_R3_7(M,D) BOOST_PP_R3_6(M,D) M(6,D)
+#define BOOST_PP_R3_8(M,D) BOOST_PP_R3_7(M,D) M(7,D)
+#define BOOST_PP_R3_9(M,D) BOOST_PP_R3_8(M,D) M(8,D)
+#define BOOST_PP_R3_10(M,D) BOOST_PP_R3_9(M,D) M(9,D)
+#define BOOST_PP_R3_11(M,D) BOOST_PP_R3_10(M,D) M(10,D)
+#define BOOST_PP_R3_12(M,D) BOOST_PP_R3_11(M,D) M(11,D)
+#define BOOST_PP_R3_13(M,D) BOOST_PP_R3_12(M,D) M(12,D)
+#define BOOST_PP_R3_14(M,D) BOOST_PP_R3_13(M,D) M(13,D)
+#define BOOST_PP_R3_15(M,D) BOOST_PP_R3_14(M,D) M(14,D)
+#define BOOST_PP_R3_16(M,D) BOOST_PP_R3_15(M,D) M(15,D)
+#define BOOST_PP_R3_17(M,D) BOOST_PP_R3_16(M,D) M(16,D)
+#define BOOST_PP_R3_18(M,D) BOOST_PP_R3_17(M,D) M(17,D)
+#define BOOST_PP_R3_19(M,D) BOOST_PP_R3_18(M,D) M(18,D)
+#define BOOST_PP_R3_20(M,D) BOOST_PP_R3_19(M,D) M(19,D)
+#define BOOST_PP_R3_21(M,D) BOOST_PP_R3_20(M,D) M(20,D)
+#define BOOST_PP_R3_22(M,D) BOOST_PP_R3_21(M,D) M(21,D)
+#define BOOST_PP_R3_23(M,D) BOOST_PP_R3_22(M,D) M(22,D)
+#define BOOST_PP_R3_24(M,D) BOOST_PP_R3_23(M,D) M(23,D)
+#define BOOST_PP_R3_25(M,D) BOOST_PP_R3_24(M,D) M(24,D)
+#define BOOST_PP_R3_26(M,D) BOOST_PP_R3_25(M,D) M(25,D)
+#define BOOST_PP_R3_27(M,D) BOOST_PP_R3_26(M,D) M(26,D)
+#define BOOST_PP_R3_28(M,D) BOOST_PP_R3_27(M,D) M(27,D)
+#define BOOST_PP_R3_29(M,D) BOOST_PP_R3_28(M,D) M(28,D)
+#define BOOST_PP_R3_30(M,D) BOOST_PP_R3_29(M,D) M(29,D)
+#define BOOST_PP_R3_31(M,D) BOOST_PP_R3_30(M,D) M(30,D)
+#define BOOST_PP_R3_32(M,D) BOOST_PP_R3_31(M,D) M(31,D)
+#define BOOST_PP_R3_33(M,D) BOOST_PP_R3_32(M,D) M(32,D)
+#define BOOST_PP_R3_34(M,D) BOOST_PP_R3_33(M,D) M(33,D)
+#define BOOST_PP_R3_35(M,D) BOOST_PP_R3_34(M,D) M(34,D)
+#define BOOST_PP_R3_36(M,D) BOOST_PP_R3_35(M,D) M(35,D)
+#define BOOST_PP_R3_37(M,D) BOOST_PP_R3_36(M,D) M(36,D)
+#define BOOST_PP_R3_38(M,D) BOOST_PP_R3_37(M,D) M(37,D)
+#define BOOST_PP_R3_39(M,D) BOOST_PP_R3_38(M,D) M(38,D)
+#define BOOST_PP_R3_40(M,D) BOOST_PP_R3_39(M,D) M(39,D)
+#define BOOST_PP_R3_41(M,D) BOOST_PP_R3_40(M,D) M(40,D)
+#define BOOST_PP_R3_42(M,D) BOOST_PP_R3_41(M,D) M(41,D)
+#define BOOST_PP_R3_43(M,D) BOOST_PP_R3_42(M,D) M(42,D)
+#define BOOST_PP_R3_44(M,D) BOOST_PP_R3_43(M,D) M(43,D)
+#define BOOST_PP_R3_45(M,D) BOOST_PP_R3_44(M,D) M(44,D)
+#define BOOST_PP_R3_46(M,D) BOOST_PP_R3_45(M,D) M(45,D)
+#define BOOST_PP_R3_47(M,D) BOOST_PP_R3_46(M,D) M(46,D)
+#define BOOST_PP_R3_48(M,D) BOOST_PP_R3_47(M,D) M(47,D)
+#define BOOST_PP_R3_49(M,D) BOOST_PP_R3_48(M,D) M(48,D)
+#define BOOST_PP_R3_50(M,D) BOOST_PP_R3_49(M,D) M(49,D)
+#define BOOST_PP_R3_51(M,D) BOOST_PP_R3_50(M,D) M(50,D)
+#define BOOST_PP_R3_52(M,D) BOOST_PP_R3_51(M,D) M(51,D)
+#define BOOST_PP_R3_53(M,D) BOOST_PP_R3_52(M,D) M(52,D)
+#define BOOST_PP_R3_54(M,D) BOOST_PP_R3_53(M,D) M(53,D)
+#define BOOST_PP_R3_55(M,D) BOOST_PP_R3_54(M,D) M(54,D)
+#define BOOST_PP_R3_56(M,D) BOOST_PP_R3_55(M,D) M(55,D)
+#define BOOST_PP_R3_57(M,D) BOOST_PP_R3_56(M,D) M(56,D)
+#define BOOST_PP_R3_58(M,D) BOOST_PP_R3_57(M,D) M(57,D)
+#define BOOST_PP_R3_59(M,D) BOOST_PP_R3_58(M,D) M(58,D)
+#define BOOST_PP_R3_60(M,D) BOOST_PP_R3_59(M,D) M(59,D)
+#define BOOST_PP_R3_61(M,D) BOOST_PP_R3_60(M,D) M(60,D)
+#define BOOST_PP_R3_62(M,D) BOOST_PP_R3_61(M,D) M(61,D)
+#define BOOST_PP_R3_63(M,D) BOOST_PP_R3_62(M,D) M(62,D)
+#define BOOST_PP_R3_64(M,D) BOOST_PP_R3_63(M,D) M(63,D)
+#define BOOST_PP_R3_65(M,D) BOOST_PP_R3_64(M,D) M(64,D)
+#define BOOST_PP_R3_66(M,D) BOOST_PP_R3_65(M,D) M(65,D)
+#define BOOST_PP_R3_67(M,D) BOOST_PP_R3_66(M,D) M(66,D)
+#define BOOST_PP_R3_68(M,D) BOOST_PP_R3_67(M,D) M(67,D)
+#define BOOST_PP_R3_69(M,D) BOOST_PP_R3_68(M,D) M(68,D)
+#define BOOST_PP_R3_70(M,D) BOOST_PP_R3_69(M,D) M(69,D)
+#define BOOST_PP_R3_71(M,D) BOOST_PP_R3_70(M,D) M(70,D)
+#define BOOST_PP_R3_72(M,D) BOOST_PP_R3_71(M,D) M(71,D)
+#define BOOST_PP_R3_73(M,D) BOOST_PP_R3_72(M,D) M(72,D)
+#define BOOST_PP_R3_74(M,D) BOOST_PP_R3_73(M,D) M(73,D)
+#define BOOST_PP_R3_75(M,D) BOOST_PP_R3_74(M,D) M(74,D)
+#define BOOST_PP_R3_76(M,D) BOOST_PP_R3_75(M,D) M(75,D)
+#define BOOST_PP_R3_77(M,D) BOOST_PP_R3_76(M,D) M(76,D)
+#define BOOST_PP_R3_78(M,D) BOOST_PP_R3_77(M,D) M(77,D)
+#define BOOST_PP_R3_79(M,D) BOOST_PP_R3_78(M,D) M(78,D)
+#define BOOST_PP_R3_80(M,D) BOOST_PP_R3_79(M,D) M(79,D)
+#define BOOST_PP_R3_81(M,D) BOOST_PP_R3_80(M,D) M(80,D)
+#define BOOST_PP_R3_82(M,D) BOOST_PP_R3_81(M,D) M(81,D)
+#define BOOST_PP_R3_83(M,D) BOOST_PP_R3_82(M,D) M(82,D)
+#define BOOST_PP_R3_84(M,D) BOOST_PP_R3_83(M,D) M(83,D)
+#define BOOST_PP_R3_85(M,D) BOOST_PP_R3_84(M,D) M(84,D)
+#define BOOST_PP_R3_86(M,D) BOOST_PP_R3_85(M,D) M(85,D)
+#define BOOST_PP_R3_87(M,D) BOOST_PP_R3_86(M,D) M(86,D)
+#define BOOST_PP_R3_88(M,D) BOOST_PP_R3_87(M,D) M(87,D)
+#define BOOST_PP_R3_89(M,D) BOOST_PP_R3_88(M,D) M(88,D)
+#define BOOST_PP_R3_90(M,D) BOOST_PP_R3_89(M,D) M(89,D)
+#define BOOST_PP_R3_91(M,D) BOOST_PP_R3_90(M,D) M(90,D)
+#define BOOST_PP_R3_92(M,D) BOOST_PP_R3_91(M,D) M(91,D)
+#define BOOST_PP_R3_93(M,D) BOOST_PP_R3_92(M,D) M(92,D)
+#define BOOST_PP_R3_94(M,D) BOOST_PP_R3_93(M,D) M(93,D)
+#define BOOST_PP_R3_95(M,D) BOOST_PP_R3_94(M,D) M(94,D)
+#define BOOST_PP_R3_96(M,D) BOOST_PP_R3_95(M,D) M(95,D)
+#define BOOST_PP_R3_97(M,D) BOOST_PP_R3_96(M,D) M(96,D)
+#define BOOST_PP_R3_98(M,D) BOOST_PP_R3_97(M,D) M(97,D)
+#define BOOST_PP_R3_99(M,D) BOOST_PP_R3_98(M,D) M(98,D)
+#define BOOST_PP_R3_100(M,D) BOOST_PP_R3_99(M,D) M(99,D)
+#define BOOST_PP_R3_101(M,D) BOOST_PP_R3_100(M,D) M(100,D)
+#define BOOST_PP_R3_102(M,D) BOOST_PP_R3_101(M,D) M(101,D)
+#define BOOST_PP_R3_103(M,D) BOOST_PP_R3_102(M,D) M(102,D)
+#define BOOST_PP_R3_104(M,D) BOOST_PP_R3_103(M,D) M(103,D)
+#define BOOST_PP_R3_105(M,D) BOOST_PP_R3_104(M,D) M(104,D)
+#define BOOST_PP_R3_106(M,D) BOOST_PP_R3_105(M,D) M(105,D)
+#define BOOST_PP_R3_107(M,D) BOOST_PP_R3_106(M,D) M(106,D)
+#define BOOST_PP_R3_108(M,D) BOOST_PP_R3_107(M,D) M(107,D)
+#define BOOST_PP_R3_109(M,D) BOOST_PP_R3_108(M,D) M(108,D)
+#define BOOST_PP_R3_110(M,D) BOOST_PP_R3_109(M,D) M(109,D)
+#define BOOST_PP_R3_111(M,D) BOOST_PP_R3_110(M,D) M(110,D)
+#define BOOST_PP_R3_112(M,D) BOOST_PP_R3_111(M,D) M(111,D)
+#define BOOST_PP_R3_113(M,D) BOOST_PP_R3_112(M,D) M(112,D)
+#define BOOST_PP_R3_114(M,D) BOOST_PP_R3_113(M,D) M(113,D)
+#define BOOST_PP_R3_115(M,D) BOOST_PP_R3_114(M,D) M(114,D)
+#define BOOST_PP_R3_116(M,D) BOOST_PP_R3_115(M,D) M(115,D)
+#define BOOST_PP_R3_117(M,D) BOOST_PP_R3_116(M,D) M(116,D)
+#define BOOST_PP_R3_118(M,D) BOOST_PP_R3_117(M,D) M(117,D)
+#define BOOST_PP_R3_119(M,D) BOOST_PP_R3_118(M,D) M(118,D)
+#define BOOST_PP_R3_120(M,D) BOOST_PP_R3_119(M,D) M(119,D)
+#define BOOST_PP_R3_121(M,D) BOOST_PP_R3_120(M,D) M(120,D)
+#define BOOST_PP_R3_122(M,D) BOOST_PP_R3_121(M,D) M(121,D)
+#define BOOST_PP_R3_123(M,D) BOOST_PP_R3_122(M,D) M(122,D)
+#define BOOST_PP_R3_124(M,D) BOOST_PP_R3_123(M,D) M(123,D)
+#define BOOST_PP_R3_125(M,D) BOOST_PP_R3_124(M,D) M(124,D)
+#define BOOST_PP_R3_126(M,D) BOOST_PP_R3_125(M,D) M(125,D)
+#define BOOST_PP_R3_127(M,D) BOOST_PP_R3_126(M,D) M(126,D)
+#define BOOST_PP_R3_128(M,D) BOOST_PP_R3_127(M,D) M(127,D)
+
+/** <p>Obsolete, just use BOOST_PP_REPEAT().</p> */
+#define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT
+/** <p>Obsolete, just use BOOST_PP_REPEAT().</p> */
+#define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT
 #endif
diff --git a/boost/boost/preprocessor/repeat_2nd.hpp b/boost/boost/preprocessor/repeat_2nd.hpp
index 6489ceff09..2edbe3d238 100644
--- a/boost/boost/preprocessor/repeat_2nd.hpp
+++ b/boost/boost/preprocessor/repeat_2nd.hpp
@@ -13,146 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-/** <p>Same as BOOST_PP_REPEAT(), but implemented independently.</p>
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-<h3>Test</h3>
-<ul>
-  <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
-</ul>
+<pre>
+#include &lt;boost/preprocessor/repeat.hpp&gt;
+</pre>
 */
-#define BOOST_PP_REPEAT_2ND(COUNT,MACRO,DATA) BOOST_PP_REPEAT_2ND_DELAY(COUNT)(MACRO,DATA)
 
-#define BOOST_PP_REPEAT_2ND_DELAY(C) BOOST_PP_REPEAT_2ND##C
-#define BOOST_PP_REPEAT_2ND0(M,D)
-#define BOOST_PP_REPEAT_2ND1(M,D) M(0,D)
-#define BOOST_PP_REPEAT_2ND2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT_2ND3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT_2ND4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT_2ND5(M,D) BOOST_PP_REPEAT_2ND4(M,D) M(4,D)
-#define BOOST_PP_REPEAT_2ND6(M,D) BOOST_PP_REPEAT_2ND5(M,D) M(5,D)
-#define BOOST_PP_REPEAT_2ND7(M,D) BOOST_PP_REPEAT_2ND6(M,D) M(6,D)
-#define BOOST_PP_REPEAT_2ND8(M,D) BOOST_PP_REPEAT_2ND7(M,D) M(7,D)
-#define BOOST_PP_REPEAT_2ND9(M,D) BOOST_PP_REPEAT_2ND8(M,D) M(8,D)
-#define BOOST_PP_REPEAT_2ND10(M,D) BOOST_PP_REPEAT_2ND9(M,D) M(9,D)
-#define BOOST_PP_REPEAT_2ND11(M,D) BOOST_PP_REPEAT_2ND10(M,D) M(10,D)
-#define BOOST_PP_REPEAT_2ND12(M,D) BOOST_PP_REPEAT_2ND11(M,D) M(11,D)
-#define BOOST_PP_REPEAT_2ND13(M,D) BOOST_PP_REPEAT_2ND12(M,D) M(12,D)
-#define BOOST_PP_REPEAT_2ND14(M,D) BOOST_PP_REPEAT_2ND13(M,D) M(13,D)
-#define BOOST_PP_REPEAT_2ND15(M,D) BOOST_PP_REPEAT_2ND14(M,D) M(14,D)
-#define BOOST_PP_REPEAT_2ND16(M,D) BOOST_PP_REPEAT_2ND15(M,D) M(15,D)
-#define BOOST_PP_REPEAT_2ND17(M,D) BOOST_PP_REPEAT_2ND16(M,D) M(16,D)
-#define BOOST_PP_REPEAT_2ND18(M,D) BOOST_PP_REPEAT_2ND17(M,D) M(17,D)
-#define BOOST_PP_REPEAT_2ND19(M,D) BOOST_PP_REPEAT_2ND18(M,D) M(18,D)
-#define BOOST_PP_REPEAT_2ND20(M,D) BOOST_PP_REPEAT_2ND19(M,D) M(19,D)
-#define BOOST_PP_REPEAT_2ND21(M,D) BOOST_PP_REPEAT_2ND20(M,D) M(20,D)
-#define BOOST_PP_REPEAT_2ND22(M,D) BOOST_PP_REPEAT_2ND21(M,D) M(21,D)
-#define BOOST_PP_REPEAT_2ND23(M,D) BOOST_PP_REPEAT_2ND22(M,D) M(22,D)
-#define BOOST_PP_REPEAT_2ND24(M,D) BOOST_PP_REPEAT_2ND23(M,D) M(23,D)
-#define BOOST_PP_REPEAT_2ND25(M,D) BOOST_PP_REPEAT_2ND24(M,D) M(24,D)
-#define BOOST_PP_REPEAT_2ND26(M,D) BOOST_PP_REPEAT_2ND25(M,D) M(25,D)
-#define BOOST_PP_REPEAT_2ND27(M,D) BOOST_PP_REPEAT_2ND26(M,D) M(26,D)
-#define BOOST_PP_REPEAT_2ND28(M,D) BOOST_PP_REPEAT_2ND27(M,D) M(27,D)
-#define BOOST_PP_REPEAT_2ND29(M,D) BOOST_PP_REPEAT_2ND28(M,D) M(28,D)
-#define BOOST_PP_REPEAT_2ND30(M,D) BOOST_PP_REPEAT_2ND29(M,D) M(29,D)
-#define BOOST_PP_REPEAT_2ND31(M,D) BOOST_PP_REPEAT_2ND30(M,D) M(30,D)
-#define BOOST_PP_REPEAT_2ND32(M,D) BOOST_PP_REPEAT_2ND31(M,D) M(31,D)
-#define BOOST_PP_REPEAT_2ND33(M,D) BOOST_PP_REPEAT_2ND32(M,D) M(32,D)
-#define BOOST_PP_REPEAT_2ND34(M,D) BOOST_PP_REPEAT_2ND33(M,D) M(33,D)
-#define BOOST_PP_REPEAT_2ND35(M,D) BOOST_PP_REPEAT_2ND34(M,D) M(34,D)
-#define BOOST_PP_REPEAT_2ND36(M,D) BOOST_PP_REPEAT_2ND35(M,D) M(35,D)
-#define BOOST_PP_REPEAT_2ND37(M,D) BOOST_PP_REPEAT_2ND36(M,D) M(36,D)
-#define BOOST_PP_REPEAT_2ND38(M,D) BOOST_PP_REPEAT_2ND37(M,D) M(37,D)
-#define BOOST_PP_REPEAT_2ND39(M,D) BOOST_PP_REPEAT_2ND38(M,D) M(38,D)
-#define BOOST_PP_REPEAT_2ND40(M,D) BOOST_PP_REPEAT_2ND39(M,D) M(39,D)
-#define BOOST_PP_REPEAT_2ND41(M,D) BOOST_PP_REPEAT_2ND40(M,D) M(40,D)
-#define BOOST_PP_REPEAT_2ND42(M,D) BOOST_PP_REPEAT_2ND41(M,D) M(41,D)
-#define BOOST_PP_REPEAT_2ND43(M,D) BOOST_PP_REPEAT_2ND42(M,D) M(42,D)
-#define BOOST_PP_REPEAT_2ND44(M,D) BOOST_PP_REPEAT_2ND43(M,D) M(43,D)
-#define BOOST_PP_REPEAT_2ND45(M,D) BOOST_PP_REPEAT_2ND44(M,D) M(44,D)
-#define BOOST_PP_REPEAT_2ND46(M,D) BOOST_PP_REPEAT_2ND45(M,D) M(45,D)
-#define BOOST_PP_REPEAT_2ND47(M,D) BOOST_PP_REPEAT_2ND46(M,D) M(46,D)
-#define BOOST_PP_REPEAT_2ND48(M,D) BOOST_PP_REPEAT_2ND47(M,D) M(47,D)
-#define BOOST_PP_REPEAT_2ND49(M,D) BOOST_PP_REPEAT_2ND48(M,D) M(48,D)
-#define BOOST_PP_REPEAT_2ND50(M,D) BOOST_PP_REPEAT_2ND49(M,D) M(49,D)
-#define BOOST_PP_REPEAT_2ND51(M,D) BOOST_PP_REPEAT_2ND50(M,D) M(50,D)
-#define BOOST_PP_REPEAT_2ND52(M,D) BOOST_PP_REPEAT_2ND51(M,D) M(51,D)
-#define BOOST_PP_REPEAT_2ND53(M,D) BOOST_PP_REPEAT_2ND52(M,D) M(52,D)
-#define BOOST_PP_REPEAT_2ND54(M,D) BOOST_PP_REPEAT_2ND53(M,D) M(53,D)
-#define BOOST_PP_REPEAT_2ND55(M,D) BOOST_PP_REPEAT_2ND54(M,D) M(54,D)
-#define BOOST_PP_REPEAT_2ND56(M,D) BOOST_PP_REPEAT_2ND55(M,D) M(55,D)
-#define BOOST_PP_REPEAT_2ND57(M,D) BOOST_PP_REPEAT_2ND56(M,D) M(56,D)
-#define BOOST_PP_REPEAT_2ND58(M,D) BOOST_PP_REPEAT_2ND57(M,D) M(57,D)
-#define BOOST_PP_REPEAT_2ND59(M,D) BOOST_PP_REPEAT_2ND58(M,D) M(58,D)
-#define BOOST_PP_REPEAT_2ND60(M,D) BOOST_PP_REPEAT_2ND59(M,D) M(59,D)
-#define BOOST_PP_REPEAT_2ND61(M,D) BOOST_PP_REPEAT_2ND60(M,D) M(60,D)
-#define BOOST_PP_REPEAT_2ND62(M,D) BOOST_PP_REPEAT_2ND61(M,D) M(61,D)
-#define BOOST_PP_REPEAT_2ND63(M,D) BOOST_PP_REPEAT_2ND62(M,D) M(62,D)
-#define BOOST_PP_REPEAT_2ND64(M,D) BOOST_PP_REPEAT_2ND63(M,D) M(63,D)
-#define BOOST_PP_REPEAT_2ND65(M,D) BOOST_PP_REPEAT_2ND64(M,D) M(64,D)
-#define BOOST_PP_REPEAT_2ND66(M,D) BOOST_PP_REPEAT_2ND65(M,D) M(65,D)
-#define BOOST_PP_REPEAT_2ND67(M,D) BOOST_PP_REPEAT_2ND66(M,D) M(66,D)
-#define BOOST_PP_REPEAT_2ND68(M,D) BOOST_PP_REPEAT_2ND67(M,D) M(67,D)
-#define BOOST_PP_REPEAT_2ND69(M,D) BOOST_PP_REPEAT_2ND68(M,D) M(68,D)
-#define BOOST_PP_REPEAT_2ND70(M,D) BOOST_PP_REPEAT_2ND69(M,D) M(69,D)
-#define BOOST_PP_REPEAT_2ND71(M,D) BOOST_PP_REPEAT_2ND70(M,D) M(70,D)
-#define BOOST_PP_REPEAT_2ND72(M,D) BOOST_PP_REPEAT_2ND71(M,D) M(71,D)
-#define BOOST_PP_REPEAT_2ND73(M,D) BOOST_PP_REPEAT_2ND72(M,D) M(72,D)
-#define BOOST_PP_REPEAT_2ND74(M,D) BOOST_PP_REPEAT_2ND73(M,D) M(73,D)
-#define BOOST_PP_REPEAT_2ND75(M,D) BOOST_PP_REPEAT_2ND74(M,D) M(74,D)
-#define BOOST_PP_REPEAT_2ND76(M,D) BOOST_PP_REPEAT_2ND75(M,D) M(75,D)
-#define BOOST_PP_REPEAT_2ND77(M,D) BOOST_PP_REPEAT_2ND76(M,D) M(76,D)
-#define BOOST_PP_REPEAT_2ND78(M,D) BOOST_PP_REPEAT_2ND77(M,D) M(77,D)
-#define BOOST_PP_REPEAT_2ND79(M,D) BOOST_PP_REPEAT_2ND78(M,D) M(78,D)
-#define BOOST_PP_REPEAT_2ND80(M,D) BOOST_PP_REPEAT_2ND79(M,D) M(79,D)
-#define BOOST_PP_REPEAT_2ND81(M,D) BOOST_PP_REPEAT_2ND80(M,D) M(80,D)
-#define BOOST_PP_REPEAT_2ND82(M,D) BOOST_PP_REPEAT_2ND81(M,D) M(81,D)
-#define BOOST_PP_REPEAT_2ND83(M,D) BOOST_PP_REPEAT_2ND82(M,D) M(82,D)
-#define BOOST_PP_REPEAT_2ND84(M,D) BOOST_PP_REPEAT_2ND83(M,D) M(83,D)
-#define BOOST_PP_REPEAT_2ND85(M,D) BOOST_PP_REPEAT_2ND84(M,D) M(84,D)
-#define BOOST_PP_REPEAT_2ND86(M,D) BOOST_PP_REPEAT_2ND85(M,D) M(85,D)
-#define BOOST_PP_REPEAT_2ND87(M,D) BOOST_PP_REPEAT_2ND86(M,D) M(86,D)
-#define BOOST_PP_REPEAT_2ND88(M,D) BOOST_PP_REPEAT_2ND87(M,D) M(87,D)
-#define BOOST_PP_REPEAT_2ND89(M,D) BOOST_PP_REPEAT_2ND88(M,D) M(88,D)
-#define BOOST_PP_REPEAT_2ND90(M,D) BOOST_PP_REPEAT_2ND89(M,D) M(89,D)
-#define BOOST_PP_REPEAT_2ND91(M,D) BOOST_PP_REPEAT_2ND90(M,D) M(90,D)
-#define BOOST_PP_REPEAT_2ND92(M,D) BOOST_PP_REPEAT_2ND91(M,D) M(91,D)
-#define BOOST_PP_REPEAT_2ND93(M,D) BOOST_PP_REPEAT_2ND92(M,D) M(92,D)
-#define BOOST_PP_REPEAT_2ND94(M,D) BOOST_PP_REPEAT_2ND93(M,D) M(93,D)
-#define BOOST_PP_REPEAT_2ND95(M,D) BOOST_PP_REPEAT_2ND94(M,D) M(94,D)
-#define BOOST_PP_REPEAT_2ND96(M,D) BOOST_PP_REPEAT_2ND95(M,D) M(95,D)
-#define BOOST_PP_REPEAT_2ND97(M,D) BOOST_PP_REPEAT_2ND96(M,D) M(96,D)
-#define BOOST_PP_REPEAT_2ND98(M,D) BOOST_PP_REPEAT_2ND97(M,D) M(97,D)
-#define BOOST_PP_REPEAT_2ND99(M,D) BOOST_PP_REPEAT_2ND98(M,D) M(98,D)
-#define BOOST_PP_REPEAT_2ND100(M,D) BOOST_PP_REPEAT_2ND99(M,D) M(99,D)
-#define BOOST_PP_REPEAT_2ND101(M,D) BOOST_PP_REPEAT_2ND100(M,D) M(100,D)
-#define BOOST_PP_REPEAT_2ND102(M,D) BOOST_PP_REPEAT_2ND101(M,D) M(101,D)
-#define BOOST_PP_REPEAT_2ND103(M,D) BOOST_PP_REPEAT_2ND102(M,D) M(102,D)
-#define BOOST_PP_REPEAT_2ND104(M,D) BOOST_PP_REPEAT_2ND103(M,D) M(103,D)
-#define BOOST_PP_REPEAT_2ND105(M,D) BOOST_PP_REPEAT_2ND104(M,D) M(104,D)
-#define BOOST_PP_REPEAT_2ND106(M,D) BOOST_PP_REPEAT_2ND105(M,D) M(105,D)
-#define BOOST_PP_REPEAT_2ND107(M,D) BOOST_PP_REPEAT_2ND106(M,D) M(106,D)
-#define BOOST_PP_REPEAT_2ND108(M,D) BOOST_PP_REPEAT_2ND107(M,D) M(107,D)
-#define BOOST_PP_REPEAT_2ND109(M,D) BOOST_PP_REPEAT_2ND108(M,D) M(108,D)
-#define BOOST_PP_REPEAT_2ND110(M,D) BOOST_PP_REPEAT_2ND109(M,D) M(109,D)
-#define BOOST_PP_REPEAT_2ND111(M,D) BOOST_PP_REPEAT_2ND110(M,D) M(110,D)
-#define BOOST_PP_REPEAT_2ND112(M,D) BOOST_PP_REPEAT_2ND111(M,D) M(111,D)
-#define BOOST_PP_REPEAT_2ND113(M,D) BOOST_PP_REPEAT_2ND112(M,D) M(112,D)
-#define BOOST_PP_REPEAT_2ND114(M,D) BOOST_PP_REPEAT_2ND113(M,D) M(113,D)
-#define BOOST_PP_REPEAT_2ND115(M,D) BOOST_PP_REPEAT_2ND114(M,D) M(114,D)
-#define BOOST_PP_REPEAT_2ND116(M,D) BOOST_PP_REPEAT_2ND115(M,D) M(115,D)
-#define BOOST_PP_REPEAT_2ND117(M,D) BOOST_PP_REPEAT_2ND116(M,D) M(116,D)
-#define BOOST_PP_REPEAT_2ND118(M,D) BOOST_PP_REPEAT_2ND117(M,D) M(117,D)
-#define BOOST_PP_REPEAT_2ND119(M,D) BOOST_PP_REPEAT_2ND118(M,D) M(118,D)
-#define BOOST_PP_REPEAT_2ND120(M,D) BOOST_PP_REPEAT_2ND119(M,D) M(119,D)
-#define BOOST_PP_REPEAT_2ND121(M,D) BOOST_PP_REPEAT_2ND120(M,D) M(120,D)
-#define BOOST_PP_REPEAT_2ND122(M,D) BOOST_PP_REPEAT_2ND121(M,D) M(121,D)
-#define BOOST_PP_REPEAT_2ND123(M,D) BOOST_PP_REPEAT_2ND122(M,D) M(122,D)
-#define BOOST_PP_REPEAT_2ND124(M,D) BOOST_PP_REPEAT_2ND123(M,D) M(123,D)
-#define BOOST_PP_REPEAT_2ND125(M,D) BOOST_PP_REPEAT_2ND124(M,D) M(124,D)
-#define BOOST_PP_REPEAT_2ND126(M,D) BOOST_PP_REPEAT_2ND125(M,D) M(125,D)
-#define BOOST_PP_REPEAT_2ND127(M,D) BOOST_PP_REPEAT_2ND126(M,D) M(126,D)
-#define BOOST_PP_REPEAT_2ND128(M,D) BOOST_PP_REPEAT_2ND127(M,D) M(127,D)
-
-/* <p>Obsolete. Use BOOST_PP_REPEAT_2ND().</p> */
-#define BOOST_PREPROCESSOR_REPEAT_2ND(C,M,D) BOOST_PP_REPEAT_2ND(C,M,D)
+#include <boost/preprocessor/repeat.hpp>
 #endif
diff --git a/boost/boost/preprocessor/repeat_3rd.hpp b/boost/boost/preprocessor/repeat_3rd.hpp
index cba3f8e3e0..5418ecad74 100644
--- a/boost/boost/preprocessor/repeat_3rd.hpp
+++ b/boost/boost/preprocessor/repeat_3rd.hpp
@@ -13,140 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-/** <p>Same as BOOST_PP_REPEAT(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_3RD(COUNT,MACRO,DATA) BOOST_PP_REPEAT_3RD_DELAY(COUNT)(MACRO,DATA)
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-#define BOOST_PP_REPEAT_3RD_DELAY(C) BOOST_PP_REPEAT_3RD##C
-#define BOOST_PP_REPEAT_3RD0(M,D)
-#define BOOST_PP_REPEAT_3RD1(M,D) M(0,D)
-#define BOOST_PP_REPEAT_3RD2(M,D) M(0,D) M(1,D)
-#define BOOST_PP_REPEAT_3RD3(M,D) M(0,D) M(1,D) M(2,D)
-#define BOOST_PP_REPEAT_3RD4(M,D) M(0,D) M(1,D) M(2,D) M(3,D)
-#define BOOST_PP_REPEAT_3RD5(M,D) BOOST_PP_REPEAT_3RD4(M,D) M(4,D)
-#define BOOST_PP_REPEAT_3RD6(M,D) BOOST_PP_REPEAT_3RD5(M,D) M(5,D)
-#define BOOST_PP_REPEAT_3RD7(M,D) BOOST_PP_REPEAT_3RD6(M,D) M(6,D)
-#define BOOST_PP_REPEAT_3RD8(M,D) BOOST_PP_REPEAT_3RD7(M,D) M(7,D)
-#define BOOST_PP_REPEAT_3RD9(M,D) BOOST_PP_REPEAT_3RD8(M,D) M(8,D)
-#define BOOST_PP_REPEAT_3RD10(M,D) BOOST_PP_REPEAT_3RD9(M,D) M(9,D)
-#define BOOST_PP_REPEAT_3RD11(M,D) BOOST_PP_REPEAT_3RD10(M,D) M(10,D)
-#define BOOST_PP_REPEAT_3RD12(M,D) BOOST_PP_REPEAT_3RD11(M,D) M(11,D)
-#define BOOST_PP_REPEAT_3RD13(M,D) BOOST_PP_REPEAT_3RD12(M,D) M(12,D)
-#define BOOST_PP_REPEAT_3RD14(M,D) BOOST_PP_REPEAT_3RD13(M,D) M(13,D)
-#define BOOST_PP_REPEAT_3RD15(M,D) BOOST_PP_REPEAT_3RD14(M,D) M(14,D)
-#define BOOST_PP_REPEAT_3RD16(M,D) BOOST_PP_REPEAT_3RD15(M,D) M(15,D)
-#define BOOST_PP_REPEAT_3RD17(M,D) BOOST_PP_REPEAT_3RD16(M,D) M(16,D)
-#define BOOST_PP_REPEAT_3RD18(M,D) BOOST_PP_REPEAT_3RD17(M,D) M(17,D)
-#define BOOST_PP_REPEAT_3RD19(M,D) BOOST_PP_REPEAT_3RD18(M,D) M(18,D)
-#define BOOST_PP_REPEAT_3RD20(M,D) BOOST_PP_REPEAT_3RD19(M,D) M(19,D)
-#define BOOST_PP_REPEAT_3RD21(M,D) BOOST_PP_REPEAT_3RD20(M,D) M(20,D)
-#define BOOST_PP_REPEAT_3RD22(M,D) BOOST_PP_REPEAT_3RD21(M,D) M(21,D)
-#define BOOST_PP_REPEAT_3RD23(M,D) BOOST_PP_REPEAT_3RD22(M,D) M(22,D)
-#define BOOST_PP_REPEAT_3RD24(M,D) BOOST_PP_REPEAT_3RD23(M,D) M(23,D)
-#define BOOST_PP_REPEAT_3RD25(M,D) BOOST_PP_REPEAT_3RD24(M,D) M(24,D)
-#define BOOST_PP_REPEAT_3RD26(M,D) BOOST_PP_REPEAT_3RD25(M,D) M(25,D)
-#define BOOST_PP_REPEAT_3RD27(M,D) BOOST_PP_REPEAT_3RD26(M,D) M(26,D)
-#define BOOST_PP_REPEAT_3RD28(M,D) BOOST_PP_REPEAT_3RD27(M,D) M(27,D)
-#define BOOST_PP_REPEAT_3RD29(M,D) BOOST_PP_REPEAT_3RD28(M,D) M(28,D)
-#define BOOST_PP_REPEAT_3RD30(M,D) BOOST_PP_REPEAT_3RD29(M,D) M(29,D)
-#define BOOST_PP_REPEAT_3RD31(M,D) BOOST_PP_REPEAT_3RD30(M,D) M(30,D)
-#define BOOST_PP_REPEAT_3RD32(M,D) BOOST_PP_REPEAT_3RD31(M,D) M(31,D)
-#define BOOST_PP_REPEAT_3RD33(M,D) BOOST_PP_REPEAT_3RD32(M,D) M(32,D)
-#define BOOST_PP_REPEAT_3RD34(M,D) BOOST_PP_REPEAT_3RD33(M,D) M(33,D)
-#define BOOST_PP_REPEAT_3RD35(M,D) BOOST_PP_REPEAT_3RD34(M,D) M(34,D)
-#define BOOST_PP_REPEAT_3RD36(M,D) BOOST_PP_REPEAT_3RD35(M,D) M(35,D)
-#define BOOST_PP_REPEAT_3RD37(M,D) BOOST_PP_REPEAT_3RD36(M,D) M(36,D)
-#define BOOST_PP_REPEAT_3RD38(M,D) BOOST_PP_REPEAT_3RD37(M,D) M(37,D)
-#define BOOST_PP_REPEAT_3RD39(M,D) BOOST_PP_REPEAT_3RD38(M,D) M(38,D)
-#define BOOST_PP_REPEAT_3RD40(M,D) BOOST_PP_REPEAT_3RD39(M,D) M(39,D)
-#define BOOST_PP_REPEAT_3RD41(M,D) BOOST_PP_REPEAT_3RD40(M,D) M(40,D)
-#define BOOST_PP_REPEAT_3RD42(M,D) BOOST_PP_REPEAT_3RD41(M,D) M(41,D)
-#define BOOST_PP_REPEAT_3RD43(M,D) BOOST_PP_REPEAT_3RD42(M,D) M(42,D)
-#define BOOST_PP_REPEAT_3RD44(M,D) BOOST_PP_REPEAT_3RD43(M,D) M(43,D)
-#define BOOST_PP_REPEAT_3RD45(M,D) BOOST_PP_REPEAT_3RD44(M,D) M(44,D)
-#define BOOST_PP_REPEAT_3RD46(M,D) BOOST_PP_REPEAT_3RD45(M,D) M(45,D)
-#define BOOST_PP_REPEAT_3RD47(M,D) BOOST_PP_REPEAT_3RD46(M,D) M(46,D)
-#define BOOST_PP_REPEAT_3RD48(M,D) BOOST_PP_REPEAT_3RD47(M,D) M(47,D)
-#define BOOST_PP_REPEAT_3RD49(M,D) BOOST_PP_REPEAT_3RD48(M,D) M(48,D)
-#define BOOST_PP_REPEAT_3RD50(M,D) BOOST_PP_REPEAT_3RD49(M,D) M(49,D)
-#define BOOST_PP_REPEAT_3RD51(M,D) BOOST_PP_REPEAT_3RD50(M,D) M(50,D)
-#define BOOST_PP_REPEAT_3RD52(M,D) BOOST_PP_REPEAT_3RD51(M,D) M(51,D)
-#define BOOST_PP_REPEAT_3RD53(M,D) BOOST_PP_REPEAT_3RD52(M,D) M(52,D)
-#define BOOST_PP_REPEAT_3RD54(M,D) BOOST_PP_REPEAT_3RD53(M,D) M(53,D)
-#define BOOST_PP_REPEAT_3RD55(M,D) BOOST_PP_REPEAT_3RD54(M,D) M(54,D)
-#define BOOST_PP_REPEAT_3RD56(M,D) BOOST_PP_REPEAT_3RD55(M,D) M(55,D)
-#define BOOST_PP_REPEAT_3RD57(M,D) BOOST_PP_REPEAT_3RD56(M,D) M(56,D)
-#define BOOST_PP_REPEAT_3RD58(M,D) BOOST_PP_REPEAT_3RD57(M,D) M(57,D)
-#define BOOST_PP_REPEAT_3RD59(M,D) BOOST_PP_REPEAT_3RD58(M,D) M(58,D)
-#define BOOST_PP_REPEAT_3RD60(M,D) BOOST_PP_REPEAT_3RD59(M,D) M(59,D)
-#define BOOST_PP_REPEAT_3RD61(M,D) BOOST_PP_REPEAT_3RD60(M,D) M(60,D)
-#define BOOST_PP_REPEAT_3RD62(M,D) BOOST_PP_REPEAT_3RD61(M,D) M(61,D)
-#define BOOST_PP_REPEAT_3RD63(M,D) BOOST_PP_REPEAT_3RD62(M,D) M(62,D)
-#define BOOST_PP_REPEAT_3RD64(M,D) BOOST_PP_REPEAT_3RD63(M,D) M(63,D)
-#define BOOST_PP_REPEAT_3RD65(M,D) BOOST_PP_REPEAT_3RD64(M,D) M(64,D)
-#define BOOST_PP_REPEAT_3RD66(M,D) BOOST_PP_REPEAT_3RD65(M,D) M(65,D)
-#define BOOST_PP_REPEAT_3RD67(M,D) BOOST_PP_REPEAT_3RD66(M,D) M(66,D)
-#define BOOST_PP_REPEAT_3RD68(M,D) BOOST_PP_REPEAT_3RD67(M,D) M(67,D)
-#define BOOST_PP_REPEAT_3RD69(M,D) BOOST_PP_REPEAT_3RD68(M,D) M(68,D)
-#define BOOST_PP_REPEAT_3RD70(M,D) BOOST_PP_REPEAT_3RD69(M,D) M(69,D)
-#define BOOST_PP_REPEAT_3RD71(M,D) BOOST_PP_REPEAT_3RD70(M,D) M(70,D)
-#define BOOST_PP_REPEAT_3RD72(M,D) BOOST_PP_REPEAT_3RD71(M,D) M(71,D)
-#define BOOST_PP_REPEAT_3RD73(M,D) BOOST_PP_REPEAT_3RD72(M,D) M(72,D)
-#define BOOST_PP_REPEAT_3RD74(M,D) BOOST_PP_REPEAT_3RD73(M,D) M(73,D)
-#define BOOST_PP_REPEAT_3RD75(M,D) BOOST_PP_REPEAT_3RD74(M,D) M(74,D)
-#define BOOST_PP_REPEAT_3RD76(M,D) BOOST_PP_REPEAT_3RD75(M,D) M(75,D)
-#define BOOST_PP_REPEAT_3RD77(M,D) BOOST_PP_REPEAT_3RD76(M,D) M(76,D)
-#define BOOST_PP_REPEAT_3RD78(M,D) BOOST_PP_REPEAT_3RD77(M,D) M(77,D)
-#define BOOST_PP_REPEAT_3RD79(M,D) BOOST_PP_REPEAT_3RD78(M,D) M(78,D)
-#define BOOST_PP_REPEAT_3RD80(M,D) BOOST_PP_REPEAT_3RD79(M,D) M(79,D)
-#define BOOST_PP_REPEAT_3RD81(M,D) BOOST_PP_REPEAT_3RD80(M,D) M(80,D)
-#define BOOST_PP_REPEAT_3RD82(M,D) BOOST_PP_REPEAT_3RD81(M,D) M(81,D)
-#define BOOST_PP_REPEAT_3RD83(M,D) BOOST_PP_REPEAT_3RD82(M,D) M(82,D)
-#define BOOST_PP_REPEAT_3RD84(M,D) BOOST_PP_REPEAT_3RD83(M,D) M(83,D)
-#define BOOST_PP_REPEAT_3RD85(M,D) BOOST_PP_REPEAT_3RD84(M,D) M(84,D)
-#define BOOST_PP_REPEAT_3RD86(M,D) BOOST_PP_REPEAT_3RD85(M,D) M(85,D)
-#define BOOST_PP_REPEAT_3RD87(M,D) BOOST_PP_REPEAT_3RD86(M,D) M(86,D)
-#define BOOST_PP_REPEAT_3RD88(M,D) BOOST_PP_REPEAT_3RD87(M,D) M(87,D)
-#define BOOST_PP_REPEAT_3RD89(M,D) BOOST_PP_REPEAT_3RD88(M,D) M(88,D)
-#define BOOST_PP_REPEAT_3RD90(M,D) BOOST_PP_REPEAT_3RD89(M,D) M(89,D)
-#define BOOST_PP_REPEAT_3RD91(M,D) BOOST_PP_REPEAT_3RD90(M,D) M(90,D)
-#define BOOST_PP_REPEAT_3RD92(M,D) BOOST_PP_REPEAT_3RD91(M,D) M(91,D)
-#define BOOST_PP_REPEAT_3RD93(M,D) BOOST_PP_REPEAT_3RD92(M,D) M(92,D)
-#define BOOST_PP_REPEAT_3RD94(M,D) BOOST_PP_REPEAT_3RD93(M,D) M(93,D)
-#define BOOST_PP_REPEAT_3RD95(M,D) BOOST_PP_REPEAT_3RD94(M,D) M(94,D)
-#define BOOST_PP_REPEAT_3RD96(M,D) BOOST_PP_REPEAT_3RD95(M,D) M(95,D)
-#define BOOST_PP_REPEAT_3RD97(M,D) BOOST_PP_REPEAT_3RD96(M,D) M(96,D)
-#define BOOST_PP_REPEAT_3RD98(M,D) BOOST_PP_REPEAT_3RD97(M,D) M(97,D)
-#define BOOST_PP_REPEAT_3RD99(M,D) BOOST_PP_REPEAT_3RD98(M,D) M(98,D)
-#define BOOST_PP_REPEAT_3RD100(M,D) BOOST_PP_REPEAT_3RD99(M,D) M(99,D)
-#define BOOST_PP_REPEAT_3RD101(M,D) BOOST_PP_REPEAT_3RD100(M,D) M(100,D)
-#define BOOST_PP_REPEAT_3RD102(M,D) BOOST_PP_REPEAT_3RD101(M,D) M(101,D)
-#define BOOST_PP_REPEAT_3RD103(M,D) BOOST_PP_REPEAT_3RD102(M,D) M(102,D)
-#define BOOST_PP_REPEAT_3RD104(M,D) BOOST_PP_REPEAT_3RD103(M,D) M(103,D)
-#define BOOST_PP_REPEAT_3RD105(M,D) BOOST_PP_REPEAT_3RD104(M,D) M(104,D)
-#define BOOST_PP_REPEAT_3RD106(M,D) BOOST_PP_REPEAT_3RD105(M,D) M(105,D)
-#define BOOST_PP_REPEAT_3RD107(M,D) BOOST_PP_REPEAT_3RD106(M,D) M(106,D)
-#define BOOST_PP_REPEAT_3RD108(M,D) BOOST_PP_REPEAT_3RD107(M,D) M(107,D)
-#define BOOST_PP_REPEAT_3RD109(M,D) BOOST_PP_REPEAT_3RD108(M,D) M(108,D)
-#define BOOST_PP_REPEAT_3RD110(M,D) BOOST_PP_REPEAT_3RD109(M,D) M(109,D)
-#define BOOST_PP_REPEAT_3RD111(M,D) BOOST_PP_REPEAT_3RD110(M,D) M(110,D)
-#define BOOST_PP_REPEAT_3RD112(M,D) BOOST_PP_REPEAT_3RD111(M,D) M(111,D)
-#define BOOST_PP_REPEAT_3RD113(M,D) BOOST_PP_REPEAT_3RD112(M,D) M(112,D)
-#define BOOST_PP_REPEAT_3RD114(M,D) BOOST_PP_REPEAT_3RD113(M,D) M(113,D)
-#define BOOST_PP_REPEAT_3RD115(M,D) BOOST_PP_REPEAT_3RD114(M,D) M(114,D)
-#define BOOST_PP_REPEAT_3RD116(M,D) BOOST_PP_REPEAT_3RD115(M,D) M(115,D)
-#define BOOST_PP_REPEAT_3RD117(M,D) BOOST_PP_REPEAT_3RD116(M,D) M(116,D)
-#define BOOST_PP_REPEAT_3RD118(M,D) BOOST_PP_REPEAT_3RD117(M,D) M(117,D)
-#define BOOST_PP_REPEAT_3RD119(M,D) BOOST_PP_REPEAT_3RD118(M,D) M(118,D)
-#define BOOST_PP_REPEAT_3RD120(M,D) BOOST_PP_REPEAT_3RD119(M,D) M(119,D)
-#define BOOST_PP_REPEAT_3RD121(M,D) BOOST_PP_REPEAT_3RD120(M,D) M(120,D)
-#define BOOST_PP_REPEAT_3RD122(M,D) BOOST_PP_REPEAT_3RD121(M,D) M(121,D)
-#define BOOST_PP_REPEAT_3RD123(M,D) BOOST_PP_REPEAT_3RD122(M,D) M(122,D)
-#define BOOST_PP_REPEAT_3RD124(M,D) BOOST_PP_REPEAT_3RD123(M,D) M(123,D)
-#define BOOST_PP_REPEAT_3RD125(M,D) BOOST_PP_REPEAT_3RD124(M,D) M(124,D)
-#define BOOST_PP_REPEAT_3RD126(M,D) BOOST_PP_REPEAT_3RD125(M,D) M(125,D)
-#define BOOST_PP_REPEAT_3RD127(M,D) BOOST_PP_REPEAT_3RD126(M,D) M(126,D)
-#define BOOST_PP_REPEAT_3RD128(M,D) BOOST_PP_REPEAT_3RD127(M,D) M(127,D)
+<pre>
+#include &lt;boost/preprocessor/repeat.hpp&gt;
+</pre>
+*/
 
-/* <p>Obsolete. Use BOOST_PP_REPEAT_3RD().</p> */
-#define BOOST_PREPROCESSOR_REPEAT_3RD(C,M,D) BOOST_PP_REPEAT_3RD(C,M,D)
+#include <boost/preprocessor/repeat.hpp>
 #endif
diff --git a/boost/boost/preprocessor/repeat_from_to.hpp b/boost/boost/preprocessor/repeat_from_to.hpp
index ee2abe7949..7a4271d29e 100644
--- a/boost/boost/preprocessor/repeat_from_to.hpp
+++ b/boost/boost/preprocessor/repeat_from_to.hpp
@@ -13,9 +13,9 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/repeat.hpp>
 #include <boost/preprocessor/arithmetic/sub.hpp>
 #include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/repeat.hpp>
 
 /** <p>Repeats the macro <code>MACRO(INDEX,DATA)</code> for <code>INDEX = [FIRST,LAST)</code>.</p>
 
@@ -38,16 +38,77 @@ BOOST_PP_REPEAT_FROM_TO(4,7,TEST,X)
 X(4); X(5); X(6);
 </pre>
 
-<h3>Uses</h3>
+<h3>2D and 3D repetition</h3>
+
+<p>BOOST_PP_REPEAT_FROM_TO() implements automatic recursion. 2D and 3D repetition
+are directly supported.</p>
+
+<h3>See</h3>
 <ul>
-  <li>BOOST_PP_REPEAT()</li>
+  <li>BOOST_PP_FOR()</li>
+  <li>BOOST_PP_LIMIT_DIM</li>
+  <li>BOOST_PP_LIMIT_MAG</li>
 </ul>
 
 <h3>Test</h3>
 <ul>
   <li><a href="../../test/repeat_test.cpp">repeat_test.cpp</a></li>
+  <li><a href="../../test/repeat_2nd_test.cpp">repeat_2nd_test.cpp</a></li>
 </ul>
 */
-#define BOOST_PP_REPEAT_FROM_TO(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+#if 0
+#  define BOOST_PP_REPEAT_FROM_TO(FIRST,LAST,MACRO,DATA)
+#endif
+
+#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
+
+/* This is a workaround for a MSVC++ PP bug. You'll need to add further
+ * BOOST_PP_REPEAT_FT_AUTO_REC3/4/etc. wrapping as the maximum level of 
+ * nesting REPEATS increases
+ */
+#  define BOOST_PP_REPEAT_FROM_TO\
+    BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC2(\
+      BOOST_PP_REPEAT_FT_AUTO_REC1,(BOOST_PP_AUTO_REC_ID,(1))\
+      ))
+
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC1(M,P)\
+    BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC2(M,P)\
+    BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_FT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_FT_AUTO_REC3(M,P)\
+    (TOO MANY NESTED REPEATS!)
+
+#  define BOOST_PP_REPEAT_FT_AUTO_REC1(M,P) BOOST_PP_EXPAND(M P)
+#  define BOOST_PP_REPEAT_FT_AUTO_REC2(M,P) BOOST_PP_EXPAND(M P)
+#  define BOOST_PP_REPEAT_FT_AUTO_REC3(M,P) BOOST_PP_EXPAND(M P)
+
+#  define BOOST_PP_REPEAT_FROM_TO_1(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC1(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M1,(F,M,D)))
+#  define BOOST_PP_REPEAT_FROM_TO_2(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC2(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M2,(F,M,D)))
+#  define BOOST_PP_REPEAT_FROM_TO_3(F,L,M,D) BOOST_PP_REPEAT_FT_AUTO_REC3(BOOST_PP_REPEAT,(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M3,(F,M,D)))
+
+#else
+
+#  define BOOST_PP_REPEAT_FROM_TO\
+    BOOST_PP_AUTO_REC_CAT1(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC1(BOOST_PP_AUTO_REC_ID,(1)))
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC1(M,P)\
+    BOOST_PP_AUTO_REC_CAT2(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC2(BOOST_PP_AUTO_REC_ID,(2)))
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC2(M,P)\
+    BOOST_PP_AUTO_REC_CAT3(BOOST_PP_REPEAT_FROM_TO_,BOOST_PP_REPEAT_AUTO_REC3(BOOST_PP_AUTO_REC_ID,(3)))
+#  define BOOST_PP_REPEAT_FROM_TO_BOOST_PP_REPEAT_AUTO_REC3(M,P)\
+    (TOO MANY NESTED REPEATS!)
+
+#  define BOOST_PP_REPEAT_FROM_TO_1(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M1,(F,M,D))
+#  define BOOST_PP_REPEAT_FROM_TO_2(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M2,(F,M,D))
+#  define BOOST_PP_REPEAT_FROM_TO_3(F,L,M,D) BOOST_PP_REPEAT(BOOST_PP_SUB(L,F),BOOST_PP_REPEAT_FROM_TO_M3,(F,M,D))
+
+#endif
+
+#define BOOST_PP_REPEAT_FROM_TO_M1(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+#define BOOST_PP_REPEAT_FROM_TO_M2(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+#define BOOST_PP_REPEAT_FROM_TO_M3(I,FMD) BOOST_PP_TUPLE_ELEM(3,1,FMD)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,FMD)),BOOST_PP_TUPLE_ELEM(3,2,FMD))
+
+/** <p>Obsolete, just use BOOST_PP_REPEAT_FROM_TO().</p> */
+#define BOOST_PP_REPEAT_FROM_TO_2ND BOOST_PP_REPEAT_FROM_TO
+/** <p>Obsolete, just use BOOST_PP_REPEAT_FROM_TO().</p> */
+#define BOOST_PP_REPEAT_FROM_TO_3RD BOOST_PP_REPEAT_FROM_TO
 #endif
diff --git a/boost/boost/preprocessor/repeat_from_to_2nd.hpp b/boost/boost/preprocessor/repeat_from_to_2nd.hpp
index 6d1876ad85..e554d4cb67 100644
--- a/boost/boost/preprocessor/repeat_from_to_2nd.hpp
+++ b/boost/boost/preprocessor/repeat_from_to_2nd.hpp
@@ -13,11 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/repeat_2nd.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_FROM_TO_2ND(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT_2ND(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_2ND_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_2ND_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+<pre>
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
 #endif
diff --git a/boost/boost/preprocessor/repeat_from_to_3rd.hpp b/boost/boost/preprocessor/repeat_from_to_3rd.hpp
index cea72ee824..6898b8b15a 100644
--- a/boost/boost/preprocessor/repeat_from_to_3rd.hpp
+++ b/boost/boost/preprocessor/repeat_from_to_3rd.hpp
@@ -13,11 +13,12 @@
  * See http://www.boost.org for most recent version.
  */
 
-#include <boost/preprocessor/repeat_3rd.hpp>
-#include <boost/preprocessor/arithmetic/sub.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
+/** <p>This header is obsolete. Use the following code instead.</p>
 
-/** <p>Same as BOOST_PP_REPEAT_FROM_TO(), but implemented independently.</p> */
-#define BOOST_PP_REPEAT_FROM_TO_3RD(FIRST,LAST,MACRO,DATA) BOOST_PP_REPEAT_3RD(BOOST_PP_SUB(LAST,FIRST),BOOST_PP_REPEAT_FROM_TO_3RD_F,(FIRST,MACRO,DATA))
-#define BOOST_PP_REPEAT_FROM_TO_3RD_F(I,SMP) BOOST_PP_TUPLE_ELEM(3,1,SMP)(BOOST_PP_ADD(I,BOOST_PP_TUPLE_ELEM(3,0,SMP)),BOOST_PP_TUPLE_ELEM(3,2,SMP))
+<pre>
+#include &lt;boost/preprocessor/repeat_from_to.hpp&gt;
+</pre>
+*/
+
+#include <boost/preprocessor/repeat_from_to.hpp>
 #endif
diff --git a/boost/boost/preprocessor/stringize.hpp b/boost/boost/preprocessor/stringize.hpp
index edd606a00e..2cb528f521 100644
--- a/boost/boost/preprocessor/stringize.hpp
+++ b/boost/boost/preprocessor/stringize.hpp
@@ -31,7 +31,4 @@
 
 #define BOOST_PP_STRINGIZE_DELAY(X) BOOST_PP_DO_STRINGIZE(X)
 #define BOOST_PP_DO_STRINGIZE(X) #X
-
-/* <p>Obsolete. Use BOOST_PP_STRINGIZE().</p> */
-#define BOOST_PREPROCESSOR_STRINGIZE(E) BOOST_PP_STRINGIZE(E)
 #endif
diff --git a/boost/boost/preprocessor/tuple/eat.hpp b/boost/boost/preprocessor/tuple/eat.hpp
index d79bfe4ea4..4c01fc260d 100644
--- a/boost/boost/preprocessor/tuple/eat.hpp
+++ b/boost/boost/preprocessor/tuple/eat.hpp
@@ -13,6 +13,8 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+
 /** <p>Expands to a macro that eats a tuple of the specified size.</p>
 
 <p>BOOST_PP_TUPLE_EAT() is designed to be used with BOOST_PP_IF() like
@@ -26,9 +28,8 @@ BOOST_PP_IF(0,BOOST_PP_ENUM_PARAMS,BOOST_PP_TUPLE_EAT(2))(10,P)
 
 <p>expands to nothing.</p>
 */
-#define BOOST_PP_TUPLE_EAT(SIZE_OF_TUPLE) BOOST_PP_TUPLE_EAT_DELAY(SIZE_OF_TUPLE)
+#define BOOST_PP_TUPLE_EAT(SIZE_OF_TUPLE) BOOST_PP_DETAIL_CAT3(BOOST_PP_TUPLE,SIZE_OF_TUPLE,_EAT)
 
-#define BOOST_PP_TUPLE_EAT_DELAY(N) BOOST_PP_TUPLE##N##_EAT
 #define BOOST_PP_TUPLE0_EAT()
 #define BOOST_PP_TUPLE1_EAT(A)
 #define BOOST_PP_TUPLE2_EAT(A,B)
diff --git a/boost/boost/preprocessor/tuple/elem.hpp b/boost/boost/preprocessor/tuple/elem.hpp
index f2daac1cb5..bcc665f5a4 100644
--- a/boost/boost/preprocessor/tuple/elem.hpp
+++ b/boost/boost/preprocessor/tuple/elem.hpp
@@ -13,6 +13,9 @@
  * See http://www.boost.org for most recent version.
  */
 
+#include <boost/preprocessor/detail/cat.hpp>
+#include <boost/preprocessor/detail/expand.hpp>
+
 /** <p>Expands to the <code>INDEX</code>:th element of an <code>SIZE_OF_TUPLE</code>-tuple.</p>
 
 <p>For example,</p>
@@ -28,161 +31,24 @@ BOOST_PP_TUPLE_ELEM(2,1,(A,B))
   <li>BOOST_PP_LIMIT_TUPLE</li>
 </ul>
 */
-#if !defined(BOOST_NO_COMPILER_CONFIG) && defined(__MWERKS__)
-#  define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX,TUPLE)
-/* This is a workaround for a CodeWarrior PP bug. Strictly speaking
- * this workaround invokes undefined behavior, but it works as desired.
- */
-#  define BOOST_PP_TUPLE_ELEM_DELAY(N,I,T) BOOST_PP_TUPLE##N##_ELEM##I##T
-#elif !defined(BOOST_NO_COMPILER_CONFIG) && defined(_MSC_VER)
-#  include <boost/preprocessor/expand.hpp>
-/* This is a workaround for a MSVC++ PP bug. It should not be necessary
- * to use BOOST_PP_EXPAND(). Works on standard conforming compilers, too.
- */
-#  define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_EXPAND(BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX)TUPLE)
-#  define BOOST_PP_TUPLE_ELEM_DELAY(N,I) BOOST_PP_TUPLE##N##_ELEM##I
-#else
-#  define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_TUPLE_ELEM_DELAY(SIZE_OF_TUPLE,INDEX)TUPLE
-#  define BOOST_PP_TUPLE_ELEM_DELAY(N,I) BOOST_PP_TUPLE##N##_ELEM##I
-#endif
-
-/* TUPLE_ELEM can be implemented in O(N*N) space and O(N) time instead
- * of O(N*N*N) space and O(1) time. The current trade-off seems better.
- */
-#define BOOST_PP_TUPLE1_ELEM0(A) A
-
-#define BOOST_PP_TUPLE2_ELEM0(A,B) A
-#define BOOST_PP_TUPLE2_ELEM1(A,B) B
-
-#define BOOST_PP_TUPLE3_ELEM0(A,B,C) A
-#define BOOST_PP_TUPLE3_ELEM1(A,B,C) B
-#define BOOST_PP_TUPLE3_ELEM2(A,B,C) C
-
-#define BOOST_PP_TUPLE4_ELEM0(A,B,C,D) A
-#define BOOST_PP_TUPLE4_ELEM1(A,B,C,D) B
-#define BOOST_PP_TUPLE4_ELEM2(A,B,C,D) C
-#define BOOST_PP_TUPLE4_ELEM3(A,B,C,D) D
-
-#define BOOST_PP_TUPLE5_ELEM0(A,B,C,D,E) A
-#define BOOST_PP_TUPLE5_ELEM1(A,B,C,D,E) B
-#define BOOST_PP_TUPLE5_ELEM2(A,B,C,D,E) C
-#define BOOST_PP_TUPLE5_ELEM3(A,B,C,D,E) D
-#define BOOST_PP_TUPLE5_ELEM4(A,B,C,D,E) E
-
-#define BOOST_PP_TUPLE6_ELEM0(A,B,C,D,E,F) A
-#define BOOST_PP_TUPLE6_ELEM1(A,B,C,D,E,F) B
-#define BOOST_PP_TUPLE6_ELEM2(A,B,C,D,E,F) C
-#define BOOST_PP_TUPLE6_ELEM3(A,B,C,D,E,F) D
-#define BOOST_PP_TUPLE6_ELEM4(A,B,C,D,E,F) E
-#define BOOST_PP_TUPLE6_ELEM5(A,B,C,D,E,F) F
-
-#define BOOST_PP_TUPLE7_ELEM0(A,B,C,D,E,F,G) A
-#define BOOST_PP_TUPLE7_ELEM1(A,B,C,D,E,F,G) B
-#define BOOST_PP_TUPLE7_ELEM2(A,B,C,D,E,F,G) C
-#define BOOST_PP_TUPLE7_ELEM3(A,B,C,D,E,F,G) D
-#define BOOST_PP_TUPLE7_ELEM4(A,B,C,D,E,F,G) E
-#define BOOST_PP_TUPLE7_ELEM5(A,B,C,D,E,F,G) F
-#define BOOST_PP_TUPLE7_ELEM6(A,B,C,D,E,F,G) G
-
-#define BOOST_PP_TUPLE8_ELEM0(A,B,C,D,E,F,G,H) A
-#define BOOST_PP_TUPLE8_ELEM1(A,B,C,D,E,F,G,H) B
-#define BOOST_PP_TUPLE8_ELEM2(A,B,C,D,E,F,G,H) C
-#define BOOST_PP_TUPLE8_ELEM3(A,B,C,D,E,F,G,H) D
-#define BOOST_PP_TUPLE8_ELEM4(A,B,C,D,E,F,G,H) E
-#define BOOST_PP_TUPLE8_ELEM5(A,B,C,D,E,F,G,H) F
-#define BOOST_PP_TUPLE8_ELEM6(A,B,C,D,E,F,G,H) G
-#define BOOST_PP_TUPLE8_ELEM7(A,B,C,D,E,F,G,H) H
-
-#define BOOST_PP_TUPLE9_ELEM0(A,B,C,D,E,F,G,H,I) A
-#define BOOST_PP_TUPLE9_ELEM1(A,B,C,D,E,F,G,H,I) B
-#define BOOST_PP_TUPLE9_ELEM2(A,B,C,D,E,F,G,H,I) C
-#define BOOST_PP_TUPLE9_ELEM3(A,B,C,D,E,F,G,H,I) D
-#define BOOST_PP_TUPLE9_ELEM4(A,B,C,D,E,F,G,H,I) E
-#define BOOST_PP_TUPLE9_ELEM5(A,B,C,D,E,F,G,H,I) F
-#define BOOST_PP_TUPLE9_ELEM6(A,B,C,D,E,F,G,H,I) G
-#define BOOST_PP_TUPLE9_ELEM7(A,B,C,D,E,F,G,H,I) H
-#define BOOST_PP_TUPLE9_ELEM8(A,B,C,D,E,F,G,H,I) I
-
-#define BOOST_PP_TUPLE10_ELEM0(A,B,C,D,E,F,G,H,I,J) A
-#define BOOST_PP_TUPLE10_ELEM1(A,B,C,D,E,F,G,H,I,J) B
-#define BOOST_PP_TUPLE10_ELEM2(A,B,C,D,E,F,G,H,I,J) C
-#define BOOST_PP_TUPLE10_ELEM3(A,B,C,D,E,F,G,H,I,J) D
-#define BOOST_PP_TUPLE10_ELEM4(A,B,C,D,E,F,G,H,I,J) E
-#define BOOST_PP_TUPLE10_ELEM5(A,B,C,D,E,F,G,H,I,J) F
-#define BOOST_PP_TUPLE10_ELEM6(A,B,C,D,E,F,G,H,I,J) G
-#define BOOST_PP_TUPLE10_ELEM7(A,B,C,D,E,F,G,H,I,J) H
-#define BOOST_PP_TUPLE10_ELEM8(A,B,C,D,E,F,G,H,I,J) I
-#define BOOST_PP_TUPLE10_ELEM9(A,B,C,D,E,F,G,H,I,J) J
-
-#define BOOST_PP_TUPLE11_ELEM0(A,B,C,D,E,F,G,H,I,J,K) A
-#define BOOST_PP_TUPLE11_ELEM1(A,B,C,D,E,F,G,H,I,J,K) B
-#define BOOST_PP_TUPLE11_ELEM2(A,B,C,D,E,F,G,H,I,J,K) C
-#define BOOST_PP_TUPLE11_ELEM3(A,B,C,D,E,F,G,H,I,J,K) D
-#define BOOST_PP_TUPLE11_ELEM4(A,B,C,D,E,F,G,H,I,J,K) E
-#define BOOST_PP_TUPLE11_ELEM5(A,B,C,D,E,F,G,H,I,J,K) F
-#define BOOST_PP_TUPLE11_ELEM6(A,B,C,D,E,F,G,H,I,J,K) G
-#define BOOST_PP_TUPLE11_ELEM7(A,B,C,D,E,F,G,H,I,J,K) H
-#define BOOST_PP_TUPLE11_ELEM8(A,B,C,D,E,F,G,H,I,J,K) I
-#define BOOST_PP_TUPLE11_ELEM9(A,B,C,D,E,F,G,H,I,J,K) J
-#define BOOST_PP_TUPLE11_ELEM10(A,B,C,D,E,F,G,H,I,J,K) K
-
-#define BOOST_PP_TUPLE12_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L) A
-#define BOOST_PP_TUPLE12_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L) B
-#define BOOST_PP_TUPLE12_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L) C
-#define BOOST_PP_TUPLE12_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L) D
-#define BOOST_PP_TUPLE12_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L) E
-#define BOOST_PP_TUPLE12_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L) F
-#define BOOST_PP_TUPLE12_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L) G
-#define BOOST_PP_TUPLE12_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L) H
-#define BOOST_PP_TUPLE12_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L) I
-#define BOOST_PP_TUPLE12_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L) J
-#define BOOST_PP_TUPLE12_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L) K
-#define BOOST_PP_TUPLE12_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L) L
-
-#define BOOST_PP_TUPLE13_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M) A
-#define BOOST_PP_TUPLE13_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M) B
-#define BOOST_PP_TUPLE13_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M) C
-#define BOOST_PP_TUPLE13_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M) D
-#define BOOST_PP_TUPLE13_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M) E
-#define BOOST_PP_TUPLE13_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M) F
-#define BOOST_PP_TUPLE13_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M) G
-#define BOOST_PP_TUPLE13_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M) H
-#define BOOST_PP_TUPLE13_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M) I
-#define BOOST_PP_TUPLE13_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M) J
-#define BOOST_PP_TUPLE13_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M) K
-#define BOOST_PP_TUPLE13_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M) L
-#define BOOST_PP_TUPLE13_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M) M
-
-#define BOOST_PP_TUPLE14_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N) A
-#define BOOST_PP_TUPLE14_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N) B
-#define BOOST_PP_TUPLE14_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M,N) C
-#define BOOST_PP_TUPLE14_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M,N) D
-#define BOOST_PP_TUPLE14_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M,N) E
-#define BOOST_PP_TUPLE14_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M,N) F
-#define BOOST_PP_TUPLE14_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M,N) G
-#define BOOST_PP_TUPLE14_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M,N) H
-#define BOOST_PP_TUPLE14_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M,N) I
-#define BOOST_PP_TUPLE14_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M,N) J
-#define BOOST_PP_TUPLE14_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M,N) K
-#define BOOST_PP_TUPLE14_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M,N) L
-#define BOOST_PP_TUPLE14_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M,N) M
-#define BOOST_PP_TUPLE14_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N) N
-
-#define BOOST_PP_TUPLE15_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) A
-#define BOOST_PP_TUPLE15_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) B
-#define BOOST_PP_TUPLE15_ELEM2(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) C
-#define BOOST_PP_TUPLE15_ELEM3(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) D
-#define BOOST_PP_TUPLE15_ELEM4(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) E
-#define BOOST_PP_TUPLE15_ELEM5(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) F
-#define BOOST_PP_TUPLE15_ELEM6(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) G
-#define BOOST_PP_TUPLE15_ELEM7(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) H
-#define BOOST_PP_TUPLE15_ELEM8(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) I
-#define BOOST_PP_TUPLE15_ELEM9(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) J
-#define BOOST_PP_TUPLE15_ELEM10(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) K
-#define BOOST_PP_TUPLE15_ELEM11(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) L
-#define BOOST_PP_TUPLE15_ELEM12(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) M
-#define BOOST_PP_TUPLE15_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) N
-#define BOOST_PP_TUPLE15_ELEM14(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) O
+#define BOOST_PP_TUPLE_ELEM(SIZE_OF_TUPLE,INDEX,TUPLE) BOOST_PP_DETAIL_EXPAND(BOOST_PP_DETAIL_CAT2(BOOST_PP_TUPLE16_ELEM,INDEX) BOOST_PP_DETAIL_CAT2(BOOST_PP_TUPLE_ELEM_EX,SIZE_OF_TUPLE) TUPLE)
+
+#define BOOST_PP_TUPLE_ELEM_EX1(A) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX2(A,B) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX3(A,B,C) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX4(A,B,C,D) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX5(A,B,C,D,E) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX6(A,B,C,D,E,F) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX7(A,B,C,D,E,F,G) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX8(A,B,C,D,E,F,G,H) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX9(A,B,C,D,E,F,G,H,I) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX10(A,B,C,D,E,F,G,H,I,J) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX11(A,B,C,D,E,F,G,H,I,J,K) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX12(A,B,C,D,E,F,G,H,I,J,K,L) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX13(A,B,C,D,E,F,G,H,I,J,K,L,M) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX14(A,B,C,D,E,F,G,H,I,J,K,L,M,N) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX15(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
+#define BOOST_PP_TUPLE_ELEM_EX16(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P)
 
 #define BOOST_PP_TUPLE16_ELEM0(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) A
 #define BOOST_PP_TUPLE16_ELEM1(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) B
@@ -200,7 +66,4 @@ BOOST_PP_TUPLE_ELEM(2,1,(A,B))
 #define BOOST_PP_TUPLE16_ELEM13(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) N
 #define BOOST_PP_TUPLE16_ELEM14(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) O
 #define BOOST_PP_TUPLE16_ELEM15(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) P
-
-/* <p>Obsolete. Use BOOST_PP_TUPLE_ELEM().</p> */
-#define BOOST_PREPROCESSOR_TUPLE_ELEM(N,I,T) BOOST_PP_TUPLE_ELEM(N,I,T)
 #endif
diff --git a/boost/boost/preprocessor/while.hpp b/boost/boost/preprocessor/while.hpp
index 357c20e43c..e574c1980c 100644
--- a/boost/boost/preprocessor/while.hpp
+++ b/boost/boost/preprocessor/while.hpp
@@ -57,13 +57,21 @@ BOOST_PP_WHILE(PRED,OP,(0,3))
       C++ preprocessor.</li>
 </ul>
 
+<h3>Automatic recursion?</h3>
+
+<p>BOOST_PP_WHILE() currently does not implement automatic recursion. The reason
+for this is that it would lead to very poor performance. The automatic recursion
+technique takes O(N) steps just to find out that the Nth recursion should be used.
+This would dramatically effect the time complexity of macros using automatic
+recursion.</p>
+
 <h3>Note</h3>
 <ul>
   <li>The value of the D parameter may exceed BOOST_PP_LIMIT_MAG.</li>
   <li>Using BOOST_PP_WHILE() is a bit tricky. This is due to the C++
       preprocessor limitations. It is recommended to take a look at the
-      implementations of the various PREPROCESSOR library primitives such as
-      BOOST_PP_ADD() for additional examples.</li>
+      implementations of the various PREPROCESSOR library primitives
+      such as BOOST_PP_ADD() for additional examples.</li>
 </ul>
 
 <h3>Example</h3>
@@ -334,6 +342,6 @@ BOOST_PP_WHILE(PRED,OP,(0,3))
 #define BOOST_PP_WHILE255(P,O,S) BOOST_PP_WHILE_C(P(257,S),256,S)(P,O,O(257,S))
 #define BOOST_PP_WHILE256(P,O,S) BOOST_PP_WHILE_C(P(258,S),257,S)(P,O,O(258,S))
 #define BOOST_PP_WHILE257(P,O,S) BOOST_PP_WHILE_C(P(259,S),258,S)(P,O,O(259,S))
-#define BOOST_PP_WHILE258(P,O,S) RECURSION DEPTH EXCEEDED!
-#define BOOST_PP_WHILE259(P,O,S) RECURSION DEPTH EXCEEDED!
+#define BOOST_PP_WHILE258(P,O,S) (RECURSION DEPTH EXCEEDED!)
+#define BOOST_PP_WHILE259(P,O,S) (RECURSION DEPTH EXCEEDED!)
 #endif
diff --git a/boost/boost/property_map.hpp b/boost/boost/property_map.hpp
index b3928846bd..bafe9001f6 100644
--- a/boost/boost/property_map.hpp
+++ b/boost/boost/property_map.hpp
@@ -477,7 +477,7 @@ namespace boost {
       return (*m_c)[k];
     }
   private:
-    C* m_c;
+    C const* m_c;
   };
   
   template <class UniquePairAssociativeContainer>
diff --git a/boost/boost/regex.hpp b/boost/boost/regex.hpp
index 329e671c07..276962c4a1 100644
--- a/boost/boost/regex.hpp
+++ b/boost/boost/regex.hpp
@@ -54,7 +54,7 @@
 namespace boost{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc -w-8027
 #endif
 
 namespace re_detail{
diff --git a/boost/boost/regex/detail/fileiter.hpp b/boost/boost/regex/detail/fileiter.hpp
index 90d082a17d..bb90967587 100644
--- a/boost/boost/regex/detail/fileiter.hpp
+++ b/boost/boost/regex/detail/fileiter.hpp
@@ -81,7 +81,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-    #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 struct _fi_find_data
diff --git a/boost/boost/regex/detail/instances.hpp b/boost/boost/regex/detail/instances.hpp
index 476184417c..b286a947f9 100644
--- a/boost/boost/regex/detail/instances.hpp
+++ b/boost/boost/regex/detail/instances.hpp
@@ -40,6 +40,8 @@ namespace boost{
 
 #ifdef __BORLANDC__
 
+#pragma option push -a8 -b -Vx -Ve -pc
+
 #  ifndef BOOST_REGEX_INSTANTIATE
 #     pragma option push -Jgx
 #  endif
@@ -55,6 +57,8 @@ template class BOOST_REGEX_DECL match_results<std::basic_string<BOOST_REGEX_CHAR
 #     pragma option pop
 #  endif
 
+#pragma option pop
+
 #elif defined(BOOST_MSVC)
 
 #  ifndef BOOST_REGEX_INSTANTIATE
diff --git a/boost/boost/regex/detail/regex_compile.hpp b/boost/boost/regex/detail/regex_compile.hpp
index f13028a0bc..5ec6a262fd 100644
--- a/boost/boost/regex/detail/regex_compile.hpp
+++ b/boost/boost/regex/detail/regex_compile.hpp
@@ -26,7 +26,7 @@
 
 namespace boost{
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc  -w-8004
 #endif
    namespace re_detail{
 
@@ -607,6 +607,10 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::compile_map(
 template <class charT, class traits, class Allocator>
 void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::move_offsets(re_detail::re_syntax_base* j, unsigned size)
 {
+# ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable: 4127)
+#endif
    // move all offsets starting with j->link forward by size
    // called after an insert:
    j = reinterpret_cast<re_detail::re_syntax_base*>(reinterpret_cast<char*>(data.data()) + j->next.i);
@@ -631,6 +635,9 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::move_offsets(re_
          break;
       j = reinterpret_cast<re_detail::re_syntax_base*>(reinterpret_cast<char*>(data.data()) + j->next.i);
    }
+# ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
 }
 
 template <class charT, class traits, class Allocator>
@@ -1245,6 +1252,11 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_apply(re_d
 template <class charT, class traits, class Allocator>
 unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::set_expression(const charT* p, const charT* end, flag_type f)
 {
+# ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable: 4127)
+#endif
+
    if(p == expression())
    {
       traits_string_type s(p, end);
@@ -1912,6 +1924,11 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::set_expr
 
    } // sentry
    return REG_EMPTY;
+
+# ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
+
 }
 
 template <class charT, class traits, class Allocator>
diff --git a/boost/boost/regex/detail/regex_cstring.hpp b/boost/boost/regex/detail/regex_cstring.hpp
index 36620f37cd..99495024f0 100644
--- a/boost/boost/regex/detail/regex_cstring.hpp
+++ b/boost/boost/regex/detail/regex_cstring.hpp
@@ -35,7 +35,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 //
diff --git a/boost/boost/regex/detail/regex_format.hpp b/boost/boost/regex/detail/regex_format.hpp
index bb225b2234..5201a48909 100644
--- a/boost/boost/regex/detail/regex_format.hpp
+++ b/boost/boost/regex/detail/regex_format.hpp
@@ -40,7 +40,7 @@ enum format_flags_t{
 namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc -w-8037
+   #pragma option push -a8 -b -Vx -Ve -pc  -w-8037
 #endif
 
 template <class O, class I>
diff --git a/boost/boost/regex/detail/regex_kmp.hpp b/boost/boost/regex/detail/regex_kmp.hpp
index 3a5db1ee3b..3a5e708009 100644
--- a/boost/boost/regex/detail/regex_kmp.hpp
+++ b/boost/boost/regex/detail/regex_kmp.hpp
@@ -34,16 +34,16 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 template <class charT>
 struct kmp_info
 {
-   std::size_t size;
-   std::size_t len;
+   unsigned int size;
+   unsigned int len;
    const charT* pstr;
-   std::ptrdiff_t kmp_next[1];
+   int kmp_next[1];
 };
 
 template <class charT, class Allocator>
@@ -57,11 +57,11 @@ template <class iterator, class charT, class Trans, class Allocator>
 kmp_info<charT>* kmp_compile(iterator first, iterator last, charT, Trans translate, const Allocator& a) 
 {    
    typedef typename boost::detail::rebind_allocator<char, Allocator>::type atype;
-   std::ptrdiff_t i, j, m;
+   int i, j, m;
    i = 0;
-   m = boost::re_detail::distance(first, last);
+   m = static_cast<int>(boost::re_detail::distance(first, last));
    ++m;
-   std::size_t size = sizeof(kmp_info<charT>) + sizeof(int)*m + sizeof(charT)*m;
+   unsigned int size = sizeof(kmp_info<charT>) + sizeof(int)*m + sizeof(charT)*m;
    --m;
    //
    // allocate struct and fill it in:
@@ -109,6 +109,3 @@ kmp_info<charT>* kmp_compile(iterator first, iterator last, charT, Trans transla
 
 
 
-
-
-
diff --git a/boost/boost/regex/detail/regex_match.hpp b/boost/boost/regex/detail/regex_match.hpp
index cdcfb0086d..da97ecce62 100644
--- a/boost/boost/regex/detail/regex_match.hpp
+++ b/boost/boost/regex/detail/regex_match.hpp
@@ -31,7 +31,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc -w-8026
+   #pragma option push -a8 -b -Vx -Ve -pc  -w-8026 -w-8027
 #endif
 
 //
@@ -55,6 +55,13 @@ inline int string_compare(const std::wstring& s, const wchar_t* p)
 # define STR_COMP(s,p) string_compare(s,p)
 #endif
 
+template<class charT>
+inline const charT* re_skip_past_null(const charT* p)
+{
+  while (*p != 0) ++p;
+  return ++p;
+}
+
 template <class iterator, class charT, class traits_type, class Allocator>
 iterator BOOST_REGEX_CALL re_is_set_member(iterator next, 
                           iterator last, 
@@ -103,8 +110,7 @@ iterator BOOST_REGEX_CALL re_is_set_member(iterator next,
          if(*p == 0) // if null we've matched
             return set_->isnot ? next : (ptr == next) ? ++next : ptr;
 
-         while(*p)++p;
-         ++p;     // skip null
+         p = re_skip_past_null(p);     // skip null
       }
    }
 
@@ -283,6 +289,11 @@ bool query_match_aux(iterator first,
                      _priv_match_data<iterator, Allocator>& pd,
                      iterator* restart)
 {
+# ifdef BOOST_MSVC
+#  pragma warning(push)
+#  pragma warning(disable: 4127)
+#endif
+
    typedef access_t<charT, traits, Allocator2> access;
 
    if(e.flags() & regbase::failbit)
@@ -340,6 +351,8 @@ bool query_match_aux(iterator first,
             // longer one.
             if((flags & match_not_null) && (first == temp_match[0].first))
                goto failure;
+            if((flags & match_all) && (first != last))
+               goto failure;
             temp_match.set_second(first);
             m.maybe_assign(temp_match);
             match_found = true;
@@ -1030,6 +1043,9 @@ bool query_match_aux(iterator first,
    // if we get to here then everything has failed
    // and no match was found:
    return false;
+# ifdef BOOST_MSVC
+#  pragma warning(pop)
+#endif
 }
 #if defined(BOOST_REGEX_NO_TEMPLATE_SWITCH_MERGE)
 } // namespace
@@ -1257,9 +1273,9 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
    case regbase::restart_fixed_lit:
    {
       const kmp_info<charT>* info = access::get_kmp(e);
-     std::ptrdiff_t len = info->len;
+      int len = info->len;
       const charT* x = info->pstr;
-     std::ptrdiff_t j = 0; 
+      int j = 0; 
       bool icase = e.flags() & regbase::icase;
       while (first != last) 
       {
@@ -1639,9 +1655,7 @@ bool regex_match(iterator first, iterator last, match_results<iterator, Allocato
    re_detail::_priv_match_data<iterator, Allocator> pd(m);
    iterator restart;
    bool result = re_detail::query_match_aux(first, last, m, e, flags, pd, &restart);
-   if(result && (last == m[0].second))
-      return true;
-   return false;
+   return result;
 }
 template <class iterator, class charT, class traits, class Allocator2>
 bool regex_match(iterator first, iterator last, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
@@ -1913,3 +1927,5 @@ inline unsigned int regex_grep(bool (*foo)(const match_results<std::basic_string
 
 
 
+
+
diff --git a/boost/boost/regex/detail/regex_raw_buffer.hpp b/boost/boost/regex/detail/regex_raw_buffer.hpp
index e4a6c71fbd..19a0293b4d 100644
--- a/boost/boost/regex/detail/regex_raw_buffer.hpp
+++ b/boost/boost/regex/detail/regex_raw_buffer.hpp
@@ -33,7 +33,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 struct empty_padding{};
diff --git a/boost/boost/regex/detail/regex_split.hpp b/boost/boost/regex/detail/regex_split.hpp
index f25383ec49..37bd59a6b0 100644
--- a/boost/boost/regex/detail/regex_split.hpp
+++ b/boost/boost/regex/detail/regex_split.hpp
@@ -28,7 +28,7 @@
 namespace boost{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 namespace re_detail{
diff --git a/boost/boost/regex/detail/regex_stack.hpp b/boost/boost/regex/detail/regex_stack.hpp
index 59590b6e7e..e66d031ed9 100644
--- a/boost/boost/regex/detail/regex_stack.hpp
+++ b/boost/boost/regex/detail/regex_stack.hpp
@@ -36,7 +36,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 //
diff --git a/boost/boost/regex/detail/regex_synch.hpp b/boost/boost/regex/detail/regex_synch.hpp
index 89df81c5b3..c3e4a9f36d 100644
--- a/boost/boost/regex/detail/regex_synch.hpp
+++ b/boost/boost/regex/detail/regex_synch.hpp
@@ -47,7 +47,7 @@ namespace boost{
    namespace re_detail{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 void BOOST_REGEX_CALL re_init_threads();
diff --git a/boost/boost/regex/pattern_except.hpp b/boost/boost/regex/pattern_except.hpp
index 4a9540f4fa..6c9b5d9a57 100644
--- a/boost/boost/regex/pattern_except.hpp
+++ b/boost/boost/regex/pattern_except.hpp
@@ -28,7 +28,7 @@
 namespace boost{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 class BOOST_REGEX_DECL bad_pattern : public std::runtime_error
diff --git a/boost/boost/regex/regex_traits.hpp b/boost/boost/regex/regex_traits.hpp
index 16c19c095c..caae5887b5 100644
--- a/boost/boost/regex/regex_traits.hpp
+++ b/boost/boost/regex/regex_traits.hpp
@@ -30,7 +30,7 @@
 namespace boost{
 
 #ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
+   #pragma option push -a8 -b -Vx -Ve -pc
 #endif
 
 template <class charT>
@@ -123,6 +123,10 @@ struct BOOST_REGEX_DECL regex_traits_base
 
       syntax_max = 54
    };
+#ifdef __BORLANDC__
+private:
+   char dummy_member;
+#endif
 };
 
 struct BOOST_REGEX_DECL c_traits_base : public regex_traits_base
diff --git a/boost/boost/signal.hpp b/boost/boost/signal.hpp
index a7400096ca..60cd515dce 100644
--- a/boost/boost/signal.hpp
+++ b/boost/boost/signal.hpp
@@ -32,7 +32,7 @@
 #include <boost/signals/signal10.hpp>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       // The unusable class is a placeholder for unused function arguments.
       struct unused {};
@@ -78,7 +78,7 @@ namespace boost {
       struct real_get_signal_impl<0>
       {
         template<
-          typename R, 
+          typename R,
           typename T1,
           typename T2,
           typename T3,
@@ -89,7 +89,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -112,7 +112,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -135,7 +135,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -158,7 +158,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -181,7 +181,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -204,7 +204,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -228,7 +228,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -251,7 +251,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -274,7 +274,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -297,7 +297,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -320,7 +320,7 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename Combiner = last_value<R>
+          typename Combiner
         >
         struct params
         {
@@ -341,46 +341,49 @@ namespace boost {
         typename T8, 
         typename T9,
         typename T10,
-        typename Combiner = last_value<R>
+        typename Combiner
       >
       struct get_signal_impl
       {
-        typedef typename real_get_signal_impl<
-          (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
-          >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Combiner>::type
-        type;
+      private:
+        typedef real_get_signal_impl<
+          (::boost::BOOST_SIGNALS_NAMESPACE::detail::count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)> t1;
+        typedef typename t1::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
+                             Combiner> t2;
+      public:
+        typedef typename t2::type type;
       };
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 
   // Very lightweight wrapper around the signalN classes that allows signals to
   // be created where the number of arguments does not need to be part of the
   // class name.
   template<
     typename R, 
-    typename T1  = signals::detail::unused, 
-    typename T2  = signals::detail::unused,
-    typename T3  = signals::detail::unused,
-    typename T4  = signals::detail::unused,
-    typename T5  = signals::detail::unused,
-    typename T6  = signals::detail::unused,
-    typename T7  = signals::detail::unused,
-    typename T8  = signals::detail::unused,
-    typename T9  = signals::detail::unused,
-    typename T10 = signals::detail::unused
+    typename T1  = BOOST_SIGNALS_NAMESPACE::detail::unused, 
+    typename T2  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T3  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T4  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T5  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T6  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T7  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T8  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T9  = BOOST_SIGNALS_NAMESPACE::detail::unused,
+    typename T10 = BOOST_SIGNALS_NAMESPACE::detail::unused
   >
   class signal :
-    public signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                            T8, T9, T10>::type
+    public BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<R, T1, T2, T3, T4, T5, T6, T7,
+							    T8, T9, T10, boost::last_value<R> >::type
   {
   public:
     template<typename Combiner>
     struct combiner {
-      typedef typename signals::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
-                                                        T6, T7, T8, T9, T10, 
-                                                        Combiner>::type
-        type;
+    private:
+      typedef BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl<R, T1, T2, T3, T4, T5,
+							       T6, T7, T8, T9, T10, Combiner> t1;
+    public:
+      typedef typename t1::type type;
     };
   };
 } // end namespace boost
diff --git a/boost/boost/signals/connection.hpp b/boost/boost/signals/connection.hpp
index 19f149c545..e032ab8b85 100644
--- a/boost/boost/signals/connection.hpp
+++ b/boost/boost/signals/connection.hpp
@@ -10,7 +10,7 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
- 
+
 // For more information, see http://www.boost.org
 
 #ifndef BOOST_SIGNALS_CONNECTION_HPP
@@ -25,38 +25,38 @@
 #include <utility>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     class trackable;
 
     namespace detail {
       // Represents an object that has been bound as part of a slot, and how
       // to notify that object of a disconnect
       struct bound_object {
-        void* obj;
-        void* data;
-        void (*disconnect)(void*, void*);
-
-        bool operator==(const bound_object& other) const
-          { return obj == other.obj && data == other.data; }
-        bool operator<(const bound_object& other) const 
-          { return obj < other.obj; }
+	void* obj;
+	void* data;
+	void (*disconnect)(void*, void*);
+
+	bool operator==(const bound_object& other) const
+	  { return obj == other.obj && data == other.data; }
+	bool operator<(const bound_object& other) const
+	  { return obj < other.obj; }
       };
-      
+
       // Describes the connection between a signal and the objects that are
       // bound for a specific slot. Enables notification of the signal and the
       // slots when a disconnect is requested.
       struct basic_connection {
-        void* signal;
-        void* signal_data;
-        void (*signal_disconnect)(void*, void*);
-        
-        std::list<bound_object> bound_objects;
+	void* signal;
+	void* signal_data;
+	void (*signal_disconnect)(void*, void*);
+
+	std::list<bound_object> bound_objects;
       };
     } // end namespace detail
 
     // The user may freely pass around the "connection" object and terminate
     // the connection at any time using disconnect().
-    class connection : 
+    class connection :
       private less_than_comparable1<connection>,
       private equality_comparable1<connection>
     {
@@ -91,15 +91,15 @@ namespace boost {
       friend class trackable;
 
       // Reset this connection to refer to a different actual connection
-      void reset(signals::detail::basic_connection*);
+      void reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection*);
 
       // Add a bound object to this connection (not for users)
-      void add_bound_object(const signals::detail::bound_object& b);
+      void add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b);
 
-      friend class signals::detail::bound_objects_visitor;
+      friend class BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor;
 
       // Pointer to the actual contents of the connection
-      shared_ptr<signals::detail::basic_connection> con;
+      shared_ptr<BOOST_SIGNALS_NAMESPACE::detail::basic_connection> con;
 
       // True if the destruction of this connection object should disconnect
       bool controlling_connection;
@@ -131,28 +131,27 @@ namespace boost {
     }
 
     inline connection::connection(const connection& other) :
-      con(other.con), controlling_connection(other.controlling_connection) 
+      con(other.con), controlling_connection(other.controlling_connection)
     {
     }
 
     inline connection::~connection()
     {
       if (controlling_connection) {
-        disconnect();
+	disconnect();
       }
     }
 
-    inline void 
-    connection::reset(signals::detail::basic_connection* new_con)
+    inline void
+    connection::reset(BOOST_SIGNALS_NAMESPACE::detail::basic_connection* new_con)
     {
       con.reset(new_con);
     }
 
-    inline void 
-    connection::add_bound_object(const signals::detail::bound_object& b)
+    inline void
+    connection::add_bound_object(const BOOST_SIGNALS_NAMESPACE::detail::bound_object& b)
     {
-      // c-assert expects an int, so don't pass it a pointer
-      assert(con.get() != 0);
+      assert(con.get());
       con->bound_objects.push_back(b);
     }
 
@@ -167,7 +166,7 @@ namespace boost {
     }
 
     inline connection& connection::operator=(const connection& other)
-    { 
+    {
       connection(other).swap(*this);
       return *this;
     }
@@ -189,7 +188,7 @@ namespace boost {
     {
     }
 
-    inline 
+    inline
     scoped_connection::scoped_connection(const scoped_connection& other) :
       connection(other),
       released(other.released)
@@ -199,7 +198,7 @@ namespace boost {
     inline scoped_connection::~scoped_connection()
     {
       if (!released) {
-        this->disconnect();
+	this->disconnect();
       }
     }
 
@@ -222,14 +221,14 @@ namespace boost {
       c1.swap(c2);
     }
 
-    inline scoped_connection& 
+    inline scoped_connection&
     scoped_connection::operator=(const connection& other)
     {
       scoped_connection(other).swap(*this);
       return *this;
     }
 
-    inline scoped_connection& 
+    inline scoped_connection&
     scoped_connection::operator=(const scoped_connection& other)
     {
       scoped_connection(other).swap(*this);
@@ -238,55 +237,55 @@ namespace boost {
 
     namespace detail {
       struct connection_slot_pair {
-        connection first;
-        any second;
+	connection first;
+	any second;
 
-        connection_slot_pair() {}
+	connection_slot_pair() {}
 
-        connection_slot_pair(const connection& c, const any& a) 
-          : first(c), second(a) 
-        {
-        }
+	connection_slot_pair(const connection& c, const any& a)
+	  : first(c), second(a)
+	{
+	}
 
-        // Dummys to allow explicit instantiation to work
-        bool operator==(const connection_slot_pair&) const { return false; }
-        bool operator<(const connection_slot_pair&) const { return false;} 
+	// Dummys to allow explicit instantiation to work
+	bool operator==(const connection_slot_pair&) const { return false; }
+	bool operator<(const connection_slot_pair&) const { return false;}
       };
-      
+
       // Determines if the underlying connection is disconnected
       struct is_disconnected {
-        typedef std::pair<const any, connection_slot_pair> argument_type;
-        typedef bool result_type;
+	typedef std::pair<const any, connection_slot_pair> argument_type;
+	typedef bool result_type;
 
-        inline bool operator()(const argument_type& c) const
-        {
-          return !c.second.first.connected();
-        }
+	inline bool operator()(const argument_type& c) const
+	{
+	  return !c.second.first.connected();
+	}
       };
 
       // Autodisconnects the bound object when it is destroyed unless the
       // release method is invoked.
       class auto_disconnect_bound_object {
       public:
-        auto_disconnect_bound_object(const bound_object& b) : 
-          binding(b), auto_disconnect(true)
-        {
-        }
+	auto_disconnect_bound_object(const bound_object& b) :
+	  binding(b), auto_disconnect(true)
+	{
+	}
 
-        ~auto_disconnect_bound_object()
-        {
-          if (auto_disconnect)
-            binding.disconnect(binding.obj, binding.data);
-        }
+	~auto_disconnect_bound_object()
+	{
+	  if (auto_disconnect)
+	    binding.disconnect(binding.obj, binding.data);
+	}
 
-        void release() { auto_disconnect = false; }
+	void release() { auto_disconnect = false; }
 
       private:
-        bound_object binding;
-        bool auto_disconnect;
+	bound_object binding;
+	bool auto_disconnect;
       };
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 } // end namespace boost
 
 #endif // BOOST_SIGNALS_CONNECTION_HPP
diff --git a/boost/boost/signals/detail/signal_base.hpp b/boost/boost/signals/detail/signal_base.hpp
index c6e50f4245..7094b9c887 100644
--- a/boost/boost/signals/detail/signal_base.hpp
+++ b/boost/boost/signals/detail/signal_base.hpp
@@ -28,7 +28,7 @@
 #include <vector>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       // Forward declaration for the mapping from slot names to connections
       class named_slot_map;
@@ -145,7 +145,7 @@ namespace boost {
           slot_container_type;
         typedef slot_container_type::iterator slot_iterator;
         typedef slot_container_type::value_type stored_slot_type;
-        mutable slot_container_type slots;
+        mutable slot_container_type slots_;
       };
 
       class signal_base : public noncopyable {
@@ -182,7 +182,7 @@ namespace boost {
 	shared_ptr<signal_base_impl> impl;
       };
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 } // end namespace boost
 
 #endif // BOOST_SIGNALS_SIGNAL_BASE_HEADER
diff --git a/boost/boost/signals/detail/signals_common.hpp b/boost/boost/signals/detail/signals_common.hpp
index 606e8d4262..cb2db28835 100644
--- a/boost/boost/signals/detail/signals_common.hpp
+++ b/boost/boost/signals/detail/signals_common.hpp
@@ -16,11 +16,15 @@
 #ifndef BOOST_SIGNALS_COMMON_HEADER
 #define BOOST_SIGNALS_COMMON_HEADER
 
+#ifndef BOOST_SIGNALS_NAMESPACE
+#  define BOOST_SIGNALS_NAMESPACE signals
+#endif
+
 #include <boost/type_traits/conversion_traits.hpp>
 #include <boost/ref.hpp>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       // The unusable class is a placeholder for unused function arguments
       // It is also completely unusable except that it constructable from
@@ -149,7 +153,7 @@ namespace boost {
       class bound_objects_visitor;
       class slot_base;
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 } // end namespace boost
 
 #endif // BOOST_SIGNALS_COMMON_HEADER
diff --git a/boost/boost/signals/detail/slot_call_iterator.hpp b/boost/boost/signals/detail/slot_call_iterator.hpp
index ed611d505c..354adee4b9 100644
--- a/boost/boost/signals/detail/slot_call_iterator.hpp
+++ b/boost/boost/signals/detail/slot_call_iterator.hpp
@@ -22,7 +22,7 @@
 #include <boost/signals/connection.hpp>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       // A cached return value from a slot
       template<typename T>
@@ -114,6 +114,6 @@ namespace boost {
 	return sc_iterator(first, sc_policy(last, f));
       }
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 } // end namespace boost
 #endif // BOOST_SIGNALS_SLOT_CALL_ITERATOR
diff --git a/boost/boost/signals/signal_template.hpp b/boost/boost/signals/signal_template.hpp
index 11eaae10fa..615ee0bd63 100644
--- a/boost/boost/signals/signal_template.hpp
+++ b/boost/boost/signals/signal_template.hpp
@@ -52,10 +52,10 @@
 
 // Define commonly-used instantiations
 #define BOOST_SIGNALS_ARGS_STRUCT_INST \
-  signals::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>
+  BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_ARGS_STRUCT<BOOST_SIGNALS_TEMPLATE_ARGS>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       // Holds the arguments for a bound slot call in a single place
       template<BOOST_SIGNALS_TEMPLATE_PARMS
@@ -122,7 +122,7 @@ namespace boost {
 	};
       };
     } // namespace detail
-  } // namespace signals
+  } // namespace BOOST_SIGNALS_NAMESPACE
 
   // The actual signalN class
   template<
@@ -137,15 +137,15 @@ namespace boost {
                               BOOST_SIGNALS_TEMPLATE_ARGS> 
   >
   class BOOST_SIGNALS_SIGNAL : 
-    public signals::detail::signal_base, // management of slot list
-    public signals::trackable // signals are trackable
+    public BOOST_SIGNALS_NAMESPACE::detail::signal_base, // management of slot list
+    public BOOST_SIGNALS_NAMESPACE::trackable // signals are trackable
   {
   public:
     // The slot function type
     typedef SlotFunction slot_function_type;
 
     // Result type of a slot
-    typedef typename signals::detail::slot_result_type<R>::type
+    typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_result_type<R>::type
       slot_result_type;
 
     // Argument types
@@ -160,12 +160,12 @@ namespace boost {
 
   private:
     // The real slot name comparison object type
-    typedef signals::detail::any_bridge_compare<GroupCompare, Group>
+    typedef BOOST_SIGNALS_NAMESPACE::detail::any_bridge_compare<GroupCompare, Group>
       real_group_compare_type;
 
     // The function object passed to the slot call iterator that will call
     // the underlying slot function with its arguments bound
-    typedef signals::detail::BOOST_SIGNALS_CALL_BOUND<R> 
+    typedef BOOST_SIGNALS_NAMESPACE::detail::BOOST_SIGNALS_CALL_BOUND<R> 
       outer_bound_slot_caller;
     typedef typename outer_bound_slot_caller::template
               caller<BOOST_SIGNALS_TEMPLATE_ARGS
@@ -187,21 +187,21 @@ namespace boost {
     typedef Group group_type;
     typedef GroupCompare group_compare_type;
 
-    typedef typename signals::detail::slot_call_iterator_generator<
+    typedef typename BOOST_SIGNALS_NAMESPACE::detail::slot_call_iterator_generator<
                        call_bound_slot, 
                        slot_iterator>::type slot_call_iterator;
 
     explicit 
     BOOST_SIGNALS_SIGNAL(const Combiner& c = Combiner(),
                          const GroupCompare& comp = GroupCompare()) : 
-      signals::detail::signal_base(real_group_compare_type(comp)),
+      BOOST_SIGNALS_NAMESPACE::detail::signal_base(real_group_compare_type(comp)),
       combiner(c)
     {
     }
 
     // Connect a slot to this signal
-    signals::connection connect(const slot_type&);
-    signals::connection connect(const group_type&, const slot_type&);
+    BOOST_SIGNALS_NAMESPACE::connection connect(const slot_type&);
+    BOOST_SIGNALS_NAMESPACE::connection connect(const group_type&, const slot_type&);
 
     // Disconnect a named slot
     void disconnect(const group_type& group)
@@ -226,7 +226,7 @@ namespace boost {
     typename GroupCompare,
     typename SlotFunction
   >
-  signals::connection 
+  BOOST_SIGNALS_NAMESPACE::connection 
   BOOST_SIGNALS_SIGNAL<                                 
     R, BOOST_SIGNALS_TEMPLATE_ARGS                      
     BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS  
@@ -236,7 +236,7 @@ namespace boost {
     // If the slot has been disconnected, just return a disconnected 
     // connection
     if (!in_slot.is_active()) {
-      return signals::connection();
+      return BOOST_SIGNALS_NAMESPACE::connection();
     }
 
     return impl->connect_slot(in_slot.get_slot_function(),
@@ -253,7 +253,7 @@ namespace boost {
     typename GroupCompare,
     typename SlotFunction
   >
-  signals::connection 
+  BOOST_SIGNALS_NAMESPACE::connection 
   BOOST_SIGNALS_SIGNAL<                                 
     R, BOOST_SIGNALS_TEMPLATE_ARGS                      
     BOOST_SIGNALS_COMMA_IF_NONZERO_ARGS  
@@ -286,7 +286,7 @@ namespace boost {
   >::operator()(BOOST_SIGNALS_PARMS)
   {
     // Notify the slot handling code that we are making a call
-    signals::detail::call_notification notification(this->impl);
+    BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);
 
     // Construct a function object that will call the underlying slots
     // with the given arguments. 
@@ -298,10 +298,10 @@ namespace boost {
     call_bound_slot f(&args);
 
     // Let the combiner call the slots via a pair of input iterators
-    return combiner(signals::detail::make_slot_call_iterator(
-		      notification.impl->slots.begin(), impl->slots.end(), f),
-		    signals::detail::make_slot_call_iterator(
-		      notification.impl->slots.end(), impl->slots.end(), f));
+    return combiner(BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+		      notification.impl->slots_.begin(), impl->slots_.end(), f),
+		    BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+		      notification.impl->slots_.end(), impl->slots_.end(), f));
   }
 
   template<
@@ -324,7 +324,7 @@ namespace boost {
   >::operator()(BOOST_SIGNALS_PARMS) const
   {
     // Notify the slot handling code that we are making a call
-    signals::detail::call_notification notification(this->impl);
+    BOOST_SIGNALS_NAMESPACE::detail::call_notification notification(this->impl);
 
     // Construct a function object that will call the underlying slots
     // with the given arguments. 
@@ -337,10 +337,10 @@ namespace boost {
     call_bound_slot f(&args);
 
     // Let the combiner call the slots via a pair of input iterators
-    return combiner(signals::detail::make_slot_call_iterator(
-		      notification.impl->slots.begin(), impl->slots.end(), f),
-		    signals::detail::make_slot_call_iterator(
-		      notification.impl->slots.end(), impl->slots.end(), f));
+    return combiner(BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+		      notification.impl->slots_.begin(), impl->slots_.end(), f),
+		    BOOST_SIGNALS_NAMESPACE::detail::make_slot_call_iterator(
+		      notification.impl->slots_.end(), impl->slots_.end(), f));
   }
 } // namespace boost
 
diff --git a/boost/boost/signals/slot.hpp b/boost/boost/signals/slot.hpp
index 427e1a7d9d..6fc7216c8c 100644
--- a/boost/boost/signals/slot.hpp
+++ b/boost/boost/signals/slot.hpp
@@ -23,7 +23,7 @@
 #include <cassert>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       class slot_base {
         // We would have to enumerate all of the signalN classes here as 
@@ -45,39 +45,39 @@ namespace boost {
         // Get the slot so that it can be copied
         template<typename F> 
         reference_wrapper<const F> 
-        get_invocable_slot(const F& f, signals::detail::signal_tag)
+        get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
           { return reference_wrapper<const F>(f); }
 
         template<typename F> 
-        const F& get_invocable_slot(const F& f, signals::detail::reference_tag)
+        const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
           { return f; }
 
         template<typename F>
-        const F& get_invocable_slot(const F& f, signals::detail::value_tag)
+        const F& get_invocable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
           { return f; }
 
         // Get the slot so that it can be inspected for trackable objects
         template<typename F> 
         const F& get_inspectable_slot(const F& f,
-                                      signals::detail::signal_tag)
+                                      BOOST_SIGNALS_NAMESPACE::detail::signal_tag)
           { return f; }
 
         template<typename F> 
         const F& get_inspectable_slot(const F& f, 
-                                      signals::detail::reference_tag)
+                                      BOOST_SIGNALS_NAMESPACE::detail::reference_tag)
           { return f.get(); }
 
         template<typename F>
-        const F& get_inspectable_slot(const F& f, signals::detail::value_tag)
+        const F& get_inspectable_slot(const F& f, BOOST_SIGNALS_NAMESPACE::detail::value_tag)
           { return f; }
 
         // Determines the type of the slot - is it a signal, a reference to a
         // slot or just a normal slot.
         template<typename F>
-        typename signals::detail::get_slot_tag<F>::type
+        typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type
         tag_type(const F&)
         {
-          typename signals::detail::get_slot_tag<F>::type tag;
+          typename BOOST_SIGNALS_NAMESPACE::detail::get_slot_tag<F>::type tag;
           return tag;
         }
 
@@ -88,10 +88,10 @@ namespace boost {
         static void bound_object_destructed(void*, void*) {}
       };
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 
   template<typename SlotFunction>
-  class slot : public signals::detail::slot_base {
+  class slot : public BOOST_SIGNALS_NAMESPACE::detail::slot_base {
   public:
     template<typename F> 
     slot(const F& f) : slot_function(get_invocable_slot(f, tag_type(f)))
@@ -100,7 +100,7 @@ namespace boost {
       // An exception thrown here will allow the basic_connection to be
       // destroyed when this goes out of scope, and no other connections
       // have been made.
-      signals::detail::bound_objects_visitor do_bind(bound_objects);
+      BOOST_SIGNALS_NAMESPACE::detail::bound_objects_visitor do_bind(bound_objects);
       visit_each(do_bind, get_inspectable_slot(f, tag_type(f)));
 
       create_connection();
diff --git a/boost/boost/signals/trackable.hpp b/boost/boost/signals/trackable.hpp
index a6ed2df2cc..50dbe1ef3c 100644
--- a/boost/boost/signals/trackable.hpp
+++ b/boost/boost/signals/trackable.hpp
@@ -23,7 +23,7 @@
 #include <vector>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     // Base class for "trackable" objects that can be tracked when they are
     // bound in slot target functions. When a trackable object is destroyed,
     // the signal/slot connections are disconnected automatically.
@@ -33,7 +33,7 @@ namespace boost {
 
       friend class detail::signal_base_impl;
       friend class detail::slot_base;
-      void signal_connected(connection, signals::detail::bound_object&) const;
+      void signal_connected(connection, BOOST_SIGNALS_NAMESPACE::detail::bound_object&) const;
       
     protected:
       trackable() : connected_signals(), dying(false) {}
@@ -103,7 +103,7 @@ namespace boost {
         mutable std::vector<const trackable*>& bound_objects;
       };
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 }
 
 #endif // BOOST_SIGNALS_TRACKABLE_HPP
diff --git a/boost/boost/tuple/tuple_comparison.hpp b/boost/boost/tuple/tuple_comparison.hpp
index 2062c604ed..a20fc65a99 100644
--- a/boost/boost/tuple/tuple_comparison.hpp
+++ b/boost/boost/tuple/tuple_comparison.hpp
@@ -69,7 +69,7 @@ inline bool neq(const T1& lhs, const T2& rhs) {
          neq(lhs.get_tail(), rhs.get_tail());
 }
 template<>
-inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
 
 template<class T1, class T2>
 inline bool lt(const T1& lhs, const T2& rhs) {
diff --git a/boost/boost/type_traits/array_traits.hpp b/boost/boost/type_traits/array_traits.hpp
index 975f801fb8..622c28fcb9 100644
--- a/boost/boost/type_traits/array_traits.hpp
+++ b/boost/boost/type_traits/array_traits.hpp
@@ -9,6 +9,7 @@
 //
 #ifndef BOOST_TT_ARRAY_TRAITS_HPP
 # define BOOST_TT_ARRAY_TRAITS_HPP
+# include <cstddef>
 # include <boost/type_traits/utility.hpp>
 # include <boost/type_traits/ice.hpp>
 
diff --git a/boost/libs/regex/src/c_regex_traits.cpp b/boost/libs/regex/src/c_regex_traits.cpp
index a564541066..eb671cb109 100644
--- a/boost/libs/regex/src/c_regex_traits.cpp
+++ b/boost/libs/regex/src/c_regex_traits.cpp
@@ -22,6 +22,12 @@
 
 #define BOOST_REGEX_SOURCE
 
+#include <boost/config.hpp>
+
+# ifdef BOOST_MSVC
+#  pragma warning(disable: 4702)
+#  endif
+
 #include <clocale>
 #include <cstdio>
 #include <list>
@@ -160,6 +166,8 @@ enum syntax_map_size
    map_size = UCHAR_MAX + 1
 };
 
+std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, std::size_t id);
+
 #ifndef BOOST_NO_WREGEX
 
 BOOST_REGEX_DECL wchar_t re_zero_w;
@@ -176,13 +184,7 @@ struct syntax_map_t
 
 std::list<syntax_map_t>* syntax;
 
-#endif
-
-
-std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, std::size_t id);
-
-template <class charT>
-std::size_t BOOST_REGEX_CALL re_get_message(charT* buf, std::size_t len, std::size_t id)
+std::size_t BOOST_REGEX_CALL re_get_message(wchar_t* buf, std::size_t len, std::size_t id)
 {
    std::size_t size = _re_get_message(static_cast<char*>(0), 0, id);
    if(len < size)
@@ -192,6 +194,7 @@ std::size_t BOOST_REGEX_CALL re_get_message(charT* buf, std::size_t len, std::si
    size = boost::c_regex_traits<wchar_t>::strwiden(buf, len, cb.get());
    return size;
 }
+#endif
 
 inline std::size_t BOOST_REGEX_CALL re_get_message(char* buf, std::size_t len, std::size_t id)
 {
@@ -661,7 +664,9 @@ void BOOST_REGEX_CALL c_regex_traits<char>::m_free()
    re_free_classes();
    re_free_collate();
    --entry_count;
-   if(entry_count == 0)
+   // add reference to static member here to ensure
+   // that the linker includes it in the .exe:
+   if((entry_count == 0) && (0 != &c_regex_traits<char>::i))
    {
       delete ctype_name;
       delete collate_name;
@@ -885,7 +890,9 @@ void BOOST_REGEX_CALL c_regex_traits<wchar_t>::m_free()
    re_message_free();
    re_free_classes();
    re_free_collate();
-   if(nlsw_count == 0)
+   // add reference to static member here to ensure
+   // that the linker includes it in the .exe:
+   if((nlsw_count == 0) && (0 != &c_regex_traits<wchar_t>::init_))
    {
       // cleanup:
       delete wlocale_name;
diff --git a/boost/libs/regex/src/cpp_regex_traits.cpp b/boost/libs/regex/src/cpp_regex_traits.cpp
index 047ed6a26a..eff1999c51 100644
--- a/boost/libs/regex/src/cpp_regex_traits.cpp
+++ b/boost/libs/regex/src/cpp_regex_traits.cpp
@@ -27,6 +27,10 @@
 
 #ifndef BOOST_NO_STD_LOCALE
 
+# ifdef BOOST_MSVC
+#  pragma warning(disable:4786 4702 4127 4244)
+#  endif
+
 #include <clocale>
 #include <locale>
 #include <cstdio>
@@ -39,9 +43,8 @@
 #include <boost/scoped_array.hpp>
 #include "primary_transform.hpp"
 
-
 # ifdef BOOST_MSVC
-#  pragma warning(disable:4786)
+#  pragma warning(disable:4786 4702 4127 4244)
 #  endif
 
 namespace{
diff --git a/boost/libs/regex/src/w32_regex_traits.cpp b/boost/libs/regex/src/w32_regex_traits.cpp
index fd10d5d2ba..f234b96a5d 100644
--- a/boost/libs/regex/src/w32_regex_traits.cpp
+++ b/boost/libs/regex/src/w32_regex_traits.cpp
@@ -163,8 +163,7 @@ std::list<syntax_map_t>* syntax;
 
 std::size_t BOOST_REGEX_CALL _re_get_message(char* buf, std::size_t len, unsigned id);
 
-template <class charT>
-std::size_t BOOST_REGEX_CALL get_message(charT* buf, std::size_t len, unsigned id)
+std::size_t BOOST_REGEX_CALL get_message(wchar_t* buf, std::size_t len, unsigned id)
 {
    std::size_t size = _re_get_message(static_cast<char*>(0), 0, id);
    if(len < size)
@@ -382,9 +381,12 @@ void BOOST_REGEX_CALL w32_traits_base::do_free()
 {
    BOOST_RE_GUARD_STACK
    delete[] pclasses;
+   pclasses = 0;
    delete pcoll_names;
+   pcoll_names = 0;
 #ifndef BOOST_NO_WREGEX
    delete syntax;
+   syntax = 0;
 #endif
    if(hresmod)
    {
@@ -399,6 +401,7 @@ void BOOST_REGEX_CALL w32_traits_base::do_free()
          re_custom_error_messages[i] = 0;
       }
    }
+   is_init = false;
 }
 
 std::string BOOST_REGEX_CALL w32_traits_base::error_string(unsigned id)
@@ -498,7 +501,9 @@ w32_regex_traits<char>::~w32_regex_traits()
 #ifdef BOOST_HAS_THREADS
    re_detail::cs_guard g(*re_detail::p_re_lock);
 #endif
-   if(--entry_count == 0)
+   // add reference to static member here to ensure
+   // that the linker includes it in the .exe:
+   if((--entry_count == 0) && (0 != &w32_regex_traits<char>::i))
       do_free();
 #ifdef BOOST_HAS_THREADS
    g.acquire(false);
@@ -665,7 +670,9 @@ w32_regex_traits<wchar_t>::~w32_regex_traits()
 #ifdef BOOST_HAS_THREADS
    re_detail::cs_guard g(*re_detail::p_re_lock);
 #endif
-   if(--entry_count == 0)
+   // add reference to static member here to ensure
+   // that the linker includes it in the .exe:
+   if((--entry_count == 0) && (0 != &w32_regex_traits<wchar_t>::init_))
       do_free();
 #ifdef BOOST_HAS_THREADS
    g.acquire(false);
@@ -1093,3 +1100,4 @@ unsigned short w32_regex_traits<wchar_t>::wide_unicode_classes[] = {
 #endif // #if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
 
 
+
diff --git a/boost/libs/signals/src/connection.cpp b/boost/libs/signals/src/connection.cpp
index c8f51c0126..d30d69cc6b 100644
--- a/boost/libs/signals/src/connection.cpp
+++ b/boost/libs/signals/src/connection.cpp
@@ -17,7 +17,7 @@
 #include <cassert>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     void connection::disconnect() const
     {
       if (this->connected()) {
@@ -36,11 +36,10 @@ namespace boost {
         signal_disconnect(local_con->signal, local_con->signal_data);
       
         // Disconnect all bound objects
-        typedef std::list<signals::detail::bound_object>::iterator iterator;
+        typedef std::list<BOOST_SIGNALS_NAMESPACE::detail::bound_object>::iterator iterator;
         for (iterator i = local_con->bound_objects.begin(); 
              i != local_con->bound_objects.end(); ++i) {
-          // c-assert expects an int, so don't pass it a pointer
-          assert(i->disconnect != 0);
+          assert(i->disconnect);
           i->disconnect(i->obj, i->data);
         }
       }
@@ -50,5 +49,5 @@ namespace boost {
 
 #ifndef BOOST_MSVC
 // Explicit instantiations to keep everything in the library
-template class std::list<boost::signals::detail::bound_object>;
+template class std::list<boost::BOOST_SIGNALS_NAMESPACE::detail::bound_object>;
 #endif
diff --git a/boost/libs/signals/src/signal_base.cpp b/boost/libs/signals/src/signal_base.cpp
index fe839127b0..ccdd0cf2a6 100644
--- a/boost/libs/signals/src/signal_base.cpp
+++ b/boost/libs/signals/src/signal_base.cpp
@@ -17,11 +17,11 @@
 #include <cassert>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       signal_base_impl::signal_base_impl(const compare_type& comp) : 
 	call_depth(0),
-	slots(comp)
+	slots_(comp)
       {
         flags.delayed_disconnect = false;
         flags.clearing = false;
@@ -43,7 +43,7 @@ namespace boost {
 	if (call_depth == 0) {
           // Clearing the slot list will disconnect all slots automatically
 	  temporarily_set_clearing set_clearing(this);
-	  slots.clear();
+	  slots_.clear();
 	}
 	else {
           // We can't actually remove elements from the slot list because there
@@ -53,7 +53,7 @@ namespace boost {
           // reach zero, the call list will be cleared.
           flags.delayed_disconnect = true;
           temporarily_set_clearing set_clearing(this);
-	  for (slot_iterator i = slots.begin(); i != slots.end(); ++i) {
+	  for (slot_iterator i = slots_.begin(); i != slots_.end(); ++i) {
 	    i->second.first.disconnect();
 	  }
 	}
@@ -83,7 +83,7 @@ namespace boost {
         // Add the slot to the list. 
 
         slot_iterator pos = 
-          slots.insert(stored_slot_type(name,
+          slots_.insert(stored_slot_type(name,
                                         connection_slot_pair(slot_connection,
                                                              slot)));
 
@@ -145,7 +145,7 @@ namespace boost {
         // Disconnected slots may still be in the list of slots if
         //   a) this is called while slots are being invoked (call_depth > 0)
         //   b) an exception was thrown in remove_disconnected_slots
-        for (slot_iterator i = slots.begin(); i != slots.end(); ++i) {
+        for (slot_iterator i = slots_.begin(); i != slots_.end(); ++i) {
           if (i->second.first.connected())
             return false;
         }
@@ -156,7 +156,7 @@ namespace boost {
       void signal_base_impl::disconnect(const any& group)
       {
         std::pair<slot_iterator, slot_iterator> group_slots = 
-          slots.equal_range(group);
+          slots_.equal_range(group);
         while (group_slots.first != group_slots.second) {
           slot_iterator next = group_slots.first;
           ++next;
@@ -183,7 +183,7 @@ namespace boost {
           }
           else {
             // Just remove the slot now, it's safe
-            self->slots.erase(*slot);
+            self->slots_.erase(*slot);
           }
         }
       }
@@ -191,9 +191,9 @@ namespace boost {
       void signal_base_impl::remove_disconnected_slots() const
       {
         // Remove any disconnected slots
-        for (slot_iterator i = slots.begin(); i != slots.end(); /* none */) {
+        for (slot_iterator i = slots_.begin(); i != slots_.end(); /* none */) {
           if (!i->second.first.connected())
-            slots.erase(i++);
+            slots_.erase(i++);
           else
             ++i;
         }
@@ -224,13 +224,13 @@ namespace boost {
       {
       }
     } // namespace detail
-  } // namespace signals
+  } // namespace BOOST_SIGNALS_NAMESPACE
 } // namespace boost
 
 #ifndef BOOST_MSVC
 // Explicit instantiations to keep in the library
 template class boost::function2<bool, boost::any, boost::any>;
 template class std::multimap<boost::any, 
-                             boost::signals::detail::connection_slot_pair, 
+                             boost::BOOST_SIGNALS_NAMESPACE::detail::connection_slot_pair, 
                              boost::function2<bool, boost::any, boost::any> >;
 #endif
diff --git a/boost/libs/signals/src/slot.cpp b/boost/libs/signals/src/slot.cpp
index b76297dc42..0c23df559c 100644
--- a/boost/libs/signals/src/slot.cpp
+++ b/boost/libs/signals/src/slot.cpp
@@ -16,7 +16,7 @@
 #include <boost/signals/slot.hpp>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     namespace detail {
       void slot_base::create_connection()
       {
@@ -45,13 +45,13 @@ namespace boost {
         for(std::vector<const trackable*>::iterator i = bound_objects.begin();
             i != bound_objects.end(); ++i) {
           // Notify the object that the slot is connecting to it
-          signals::detail::bound_object binding;
+          BOOST_SIGNALS_NAMESPACE::detail::bound_object binding;
           (*i)->signal_connected(watch_bound_objects, binding);
         
           // This will notify the bound object that the connection just made
           // should be disconnected if an exception is thrown before the
           // end of this iteration
-          signals::detail::auto_disconnect_bound_object disconnector(binding);
+          BOOST_SIGNALS_NAMESPACE::detail::auto_disconnect_bound_object disconnector(binding);
 
           // Add the binding to the list of bindings for the connection
           con->bound_objects.push_back(binding);
@@ -66,5 +66,5 @@ namespace boost {
         safe_connection.release();
       }
     } // end namespace detail
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 } // end namespace boost
diff --git a/boost/libs/signals/src/trackable.cpp b/boost/libs/signals/src/trackable.cpp
index f33bdeb2cd..b2189e372e 100644
--- a/boost/libs/signals/src/trackable.cpp
+++ b/boost/libs/signals/src/trackable.cpp
@@ -17,7 +17,7 @@
 #include <algorithm>
 
 namespace boost {
-  namespace signals {
+  namespace BOOST_SIGNALS_NAMESPACE {
     void trackable::signal_disconnected(void* obj, void* data)
     {
       trackable* self = reinterpret_cast<trackable*>(obj);
@@ -36,7 +36,7 @@ namespace boost {
 
     void 
     trackable::signal_connected(connection c, 
-                                signals::detail::bound_object& binding) const
+                                BOOST_SIGNALS_NAMESPACE::detail::bound_object& binding) const
     {
       // Insert the connection
       connection_iterator pos = 
@@ -54,10 +54,10 @@ namespace boost {
     {
       dying = true;
     }
-  } // end namespace signals
+  } // end namespace BOOST_SIGNALS_NAMESPACE
 }
 
 #ifndef BOOST_MSVC
 // Explicit instantiations to keep in the library
-template class std::list<boost::signals::connection>;
+template class std::list<boost::BOOST_SIGNALS_NAMESPACE::connection>;
 #endif
-- 
2.39.2