check in preprocessed headers for Intel 5.0

[SVN r17657]

include/boost/mpl/aux_/config/compiler.hpp

@@ -44,10 +44,12 @@
 #       define BOOST_MPL_COMPILER_DIR plain
 #   endif
 
-#elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
+#elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-   || defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS)
 #   define BOOST_MPL_COMPILER_DIR no_ctps
 
+#elif defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS)
+#   define BOOST_MPL_COMPILER_DIR no_ttp
+
 #else
 #   define BOOST_MPL_COMPILER_DIR plain
 #endif

include/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp

@@ -0,0 +1,88 @@
+// preprocessed version of 'boost/mpl/aux_/advance_backward.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+template< long N > struct advance_backward;
+
+template<>
+struct advance_backward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+
+};
+
+template<>
+struct advance_backward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::prior iter1;
+        typedef iter1 type;
+    };
+
+};
+
+template<>
+struct advance_backward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::prior iter1;
+        typedef typename iter1::prior iter2;
+        typedef iter2 type;
+    };
+
+};
+
+template<>
+struct advance_backward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::prior iter1;
+        typedef typename iter1::prior iter2;
+        typedef typename iter2::prior iter3;
+        typedef iter3 type;
+    };
+
+};
+
+template<>
+struct advance_backward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::prior iter1;
+        typedef typename iter1::prior iter2;
+        typedef typename iter2::prior iter3;
+        typedef typename iter3::prior iter4;
+        typedef iter4 type;
+    };
+
+};
+
+template< long N >
+struct advance_backward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename advance_backward<4>::template apply<Iterator>::type chunk_result_;
+        typedef typename advance_backward<( (N - 4) < 0 ? 0 : N - 4 )>::template apply<chunk_result_>::type type;
+    };
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp

@@ -0,0 +1,88 @@
+// preprocessed version of 'boost/mpl/aux_/advance_forward.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+template< long N > struct advance_forward;
+
+template<>
+struct advance_forward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+
+};
+
+template<>
+struct advance_forward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::next iter1;
+        typedef iter1 type;
+    };
+
+};
+
+template<>
+struct advance_forward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::next iter1;
+        typedef typename iter1::next iter2;
+        typedef iter2 type;
+    };
+
+};
+
+template<>
+struct advance_forward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::next iter1;
+        typedef typename iter1::next iter2;
+        typedef typename iter2::next iter3;
+        typedef iter3 type;
+    };
+
+};
+
+template<>
+struct advance_forward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename iter0::next iter1;
+        typedef typename iter1::next iter2;
+        typedef typename iter2::next iter3;
+        typedef typename iter3::next iter4;
+        typedef iter4 type;
+    };
+
+};
+
+template< long N > 
+struct advance_forward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename advance_forward<4>::template apply<Iterator>::type chunk_result_;
+        typedef typename advance_forward<( (N - 4) < 0 ? 0 : N - 4 )>::template apply<chunk_result_>::type type;
+    };
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/and.hpp

@@ -0,0 +1,62 @@
+// preprocessed version of 'boost/mpl/aux_/config/use_preprocessed.hpp' header
+// see the original for copyright information
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct and_impl
+    : false_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct and_impl< true,T1,T2,T3,T4 >
+    : and_impl<
+          BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value
+        , T2, T3, T4
+        , true_
+        >
+{
+};
+
+template<>
+struct and_impl<
+          true
+        , true_, true_, true_, true_
+        >
+    : true_
+{
+};
+
+} // namespace aux
+
+template<
+      typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T1)
+    , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T2)
+    , typename T3 = true_, typename T4 = true_, typename T5 = true_
+    >
+struct and_
+
+    : aux::and_impl<
+          BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value
+        , T2, T3, T4, T5
+        >
+
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(
+          5
+        , and_
+        , (T1, T2, T3, T4, T5)
+        )
+};
+
+BOOST_MPL_AUX_VOID_SPEC_EXT(
+      2
+    , 5
+    , and_
+    )
+
+}} // namespace boost::mpl
+

include/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp

@@ -0,0 +1,172 @@
+// preprocessed version of 'boost/mpl/apply.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename F, typename T1 = void_, typename T2 = void_
+    , typename T3 = void_, typename T4 = void_, typename T5 = void_
+    >
+struct apply;
+
+template< typename F >
+struct apply0 : F
+{
+    static int const arity = 1; typedef F arg1;
+ friend class apply0_rebind;
+ typedef apply0_rebind rebind;
+ };
+ class apply0_rebind { public: template< typename U1 > struct apply : apply0<U1> { };
+ 
+};
+
+template<
+      typename F
+    >
+struct apply< F,void_,void_,void_,void_,void_ >
+    : apply0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply1
+    : F::template apply<
+          T1
+        >
+{
+    static int const arity = 2; typedef F arg1;
+ typedef T1 arg2;
+ friend class apply1_rebind;
+ typedef apply1_rebind rebind;
+ };
+ class apply1_rebind { public: template< typename U1, typename U2 > struct apply : apply1< U1,U2 > { };
+ 
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply< F,T1,void_,void_,void_,void_ >
+    : apply1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2
+    : F::template apply<
+          T1, T2
+        >
+{
+    static int const arity = 3; typedef F arg1;
+ typedef T1 arg2;
+ typedef T2 arg3;
+ friend class apply2_rebind;
+ typedef apply2_rebind rebind;
+ };
+ class apply2_rebind { public: template< typename U1, typename U2, typename U3 > struct apply : apply2< U1,U2,U3 > { };
+ 
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply< F,T1,T2,void_,void_,void_ >
+    : apply2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3
+    : F::template apply<
+          T1, T2, T3
+        >
+{
+    static int const arity = 4; typedef F arg1;
+ typedef T1 arg2;
+ typedef T2 arg3;
+ typedef T3 arg4;
+ friend class apply3_rebind;
+ typedef apply3_rebind rebind;
+ };
+ class apply3_rebind { public: template< typename U1, typename U2, typename U3, typename U4 > struct apply : apply3< U1,U2,U3,U4 > { };
+ 
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply< F,T1,T2,T3,void_,void_ >
+    : apply3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4
+    : F::template apply<
+          T1, T2, T3, T4
+        >
+{
+    static int const arity = 5; typedef F arg1;
+ typedef T1 arg2;
+ typedef T2 arg3;
+ typedef T3 arg4;
+ typedef T4 arg5;
+ friend class apply4_rebind;
+ typedef apply4_rebind rebind;
+ };
+ class apply4_rebind { public: template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply : apply4< U1,U2,U3,U4,U5 > { };
+ 
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply< F,T1,T2,T3,T4,void_ >
+    : apply4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5
+    : F::template apply<
+          T1, T2, T3, T4, T5
+        >
+{
+    static int const arity = 6; typedef F arg1;
+ typedef T1 arg2;
+ typedef T2 arg3;
+ typedef T3 arg4;
+ typedef T4 arg5;
+ typedef T5 arg6;
+ friend class apply5_rebind;
+ typedef apply5_rebind rebind;
+ };
+ class apply5_rebind { public: template< typename U1, typename U2, typename U3, typename U4, typename U5, typename U6 > struct apply : apply5< U1,U2,U3,U4,U5,U6 > { };
+ 
+};
+
+// primary template (not a specialization!)
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply
+    : apply5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp

@@ -0,0 +1,136 @@
+// preprocessed version of 'boost/mpl/arg.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<> struct arg<-1>
+{
+    static int const value = -1;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U1 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+template<> struct arg<1>
+{
+    static int const value = 1;
+    typedef arg<2> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U1 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+template<> struct arg<2>
+{
+    static int const value = 2;
+    typedef arg<3> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U2 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+template<> struct arg<3>
+{
+    static int const value = 3;
+    typedef arg<4> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U3 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+template<> struct arg<4>
+{
+    static int const value = 4;
+    typedef arg<5> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U4 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+template<> struct arg<5>
+{
+    static int const value = 5;
+    typedef arg<6> next;
+    BOOST_MPL_AUX_ARG_TYPEDEF(void_, tag)
+
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+        typedef U5 type;
+
+     private:
+        static bool const nv = !is_void_<type>::value;
+        BOOST_STATIC_ASSERT(nv);
+
+    };
+};
+
+BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1, int, arg)
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp

@@ -0,0 +1,399 @@
+// preprocessed version of 'boost/mpl/bind.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+namespace aux {
+
+template<
+      typename T, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg
+{
+    typedef T type;
+};
+
+} // namespace aux
+
+template<
+      typename F, typename T1 = void_, typename T2 = void_
+    , typename T3 = void_, typename T4 = void_, typename T5 = void_
+    >
+struct bind;
+
+template< typename F, typename T > struct bind1st;
+template< typename F, typename T > struct bind2nd;
+
+namespace aux {
+
+template<
+      int N, typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg< arg<N>,U1,U2,U3,U4,U5 >
+{
+    typedef typename mpl::arg<N>::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg< bind<F,T1,T2,T3,T4,T5>,U1,U2,U3,U4,U5 >
+{
+    typedef bind< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg< bind1st<F,T>,U1,U2,U3,U4,U5 >
+{
+    typedef bind1st< F,T > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg< bind2nd<F,T>,U1,U2,U3,U4,U5 >
+{
+    typedef bind2nd< F,T > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(
+      6
+    , bind
+    )
+
+BOOST_MPL_AUX_ARITY_SPEC(2, bind1st)
+BOOST_MPL_AUX_ARITY_SPEC(2, bind2nd)
+
+template<
+      typename F
+    >
+struct bind0
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind0<F>,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind0<F> f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(1, bind0)
+
+template<
+      typename F
+    >
+struct bind< F,void_,void_,void_,void_,void_ >
+    : bind0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct bind1
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+        typedef typename aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 >::type t1;
+
+     public:
+        typedef typename f_::template apply<t1>::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind1< F,T1 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind1< F,T1 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(2, bind1)
+
+template<
+      typename F, typename T1
+    >
+struct bind< F,T1,void_,void_,void_,void_ >
+    : bind1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+        typedef typename aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 >::type t1;
+        typedef typename aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 >::type t2;
+
+     public:
+        typedef typename f_::template apply< t1,t2 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename U1, typename U2
+    , typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind2< F,T1,T2 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind2< F,T1,T2 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(3, bind2)
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind< F,T1,T2,void_,void_,void_ >
+    : bind2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+        typedef typename aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 >::type t1;
+        typedef typename aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 >::type t2;
+        typedef typename aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 >::type t3;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename U1
+    , typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind3< F,T1,T2,T3 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind3< F,T1,T2,T3 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(4, bind3)
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind< F,T1,T2,T3,void_,void_ >
+    : bind3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+        typedef typename aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 >::type t1;
+        typedef typename aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 >::type t2;
+        typedef typename aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 >::type t3;
+        typedef typename aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 >::type t4;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3,t4 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind4< F,T1,T2,T3,T4 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind4< F,T1,T2,T3,T4 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(5, bind4)
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind< F,T1,T2,T3,T4,void_ >
+    : bind4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_;
+        typedef typename aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 >::type t1;
+        typedef typename aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 >::type t2;
+        typedef typename aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 >::type t3;
+        typedef typename aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 >::type t4;
+        typedef typename aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 >::type t5;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3,t4,t5 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind5< F,T1,T2,T3,T4,T5 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(6, bind5)
+
+// primary template (not a specialization!)
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind
+    : bind5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+template< typename F, typename T >
+struct bind1st
+{
+    template<
+          typename U
+        , typename U2 = void_, typename U3 = void_, typename U4 = void_
+        , typename U5 = void_
+        >
+    struct apply
+        : F::template apply< T,U >
+    {
+    };
+};
+
+template< typename F, typename T >
+struct bind2nd
+{
+    template<
+          typename U
+        , typename U2 = void_, typename U3 = void_, typename U4 = void_
+        , typename U5 = void_
+        >
+    struct apply
+        : F::template apply< U,T >
+    {
+    };
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp

@@ -0,0 +1,496 @@
+// preprocessed version of 'boost/mpl/bind.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+namespace aux {
+
+template<
+      typename T, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg
+{
+    typedef T type;
+};
+
+template<
+      typename T
+    , typename Arg
+    >
+struct replace_unnamed_arg
+{
+    typedef Arg next_arg;
+    typedef T type;
+};
+
+template<
+      typename Arg
+    >
+struct replace_unnamed_arg< arg<-1>,Arg >
+{
+    typedef typename Arg::next next_arg;
+    typedef Arg type;
+};
+
+} // namespace aux
+
+template<
+      typename F, typename T1 = void_, typename T2 = void_
+    , typename T3 = void_, typename T4 = void_, typename T5 = void_
+    >
+struct bind;
+
+template< typename F, typename T > struct bind1st;
+template< typename F, typename T > struct bind2nd;
+
+namespace aux {
+
+template<
+      int N, typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg< arg<N>,U1,U2,U3,U4,U5 >
+{
+    typedef typename mpl::arg<N>::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg< bind<F,T1,T2,T3,T4,T5>,U1,U2,U3,U4,U5 >
+{
+    typedef bind< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg< bind1st<F,T>,U1,U2,U3,U4,U5 >
+{
+    typedef bind1st< F,T > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+template<
+      typename F, typename T, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg< bind2nd<F,T>,U1,U2,U3,U4,U5 >
+{
+    typedef bind2nd< F,T > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(
+      6
+    , bind
+    )
+
+BOOST_MPL_AUX_ARITY_SPEC(2, bind1st)
+BOOST_MPL_AUX_ARITY_SPEC(2, bind2nd)
+
+template<
+      typename F
+    >
+struct bind0
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind0<F>,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind0<F> f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(1, bind0)
+
+template<
+      typename F
+    >
+struct bind< F,void_,void_,void_,void_,void_ >
+    : bind0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct bind1
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next_arg n2;
+        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
+
+     public:
+        typedef typename f_::template apply<t1>::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind1< F,T1 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind1< F,T1 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(2, bind1)
+
+template<
+      typename F, typename T1
+    >
+struct bind< F,T1,void_,void_,void_,void_ >
+    : bind1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next_arg n2;
+        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next_arg n3;
+        typedef typename aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 >::type t2;
+
+     public:
+        typedef typename f_::template apply< t1,t2 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename U1, typename U2
+    , typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind2< F,T1,T2 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind2< F,T1,T2 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(3, bind2)
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind< F,T1,T2,void_,void_,void_ >
+    : bind2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next_arg n2;
+        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next_arg n3;
+        typedef typename aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 >::type t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next_arg n4;
+        typedef typename aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 >::type t3;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename U1
+    , typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind3< F,T1,T2,T3 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind3< F,T1,T2,T3 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(4, bind3)
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind< F,T1,T2,T3,void_,void_ >
+    : bind3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next_arg n2;
+        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next_arg n3;
+        typedef typename aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 >::type t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next_arg n4;
+        typedef typename aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 >::type t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next_arg n5;
+        typedef typename aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 >::type t4;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3,t4 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind4< F,T1,T2,T3,T4 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind4< F,T1,T2,T3,T4 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(5, bind4)
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind< F,T1,T2,T3,T4,void_ >
+    : bind4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5
+{
+    template<
+          typename U1 = void_, typename U2 = void_, typename U3 = void_
+        , typename U4 = void_, typename U5 = void_
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg< 1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next_arg n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next_arg n2;
+        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next_arg n3;
+        typedef typename aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 >::type t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next_arg n4;
+        typedef typename aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 >::type t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next_arg n5;
+        typedef typename aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 >::type t4;
+
+        typedef aux::replace_unnamed_arg< T5,n5 > r5;
+        typedef typename r5::type a5;
+        typedef typename r5::next_arg n6;
+        typedef typename aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 >::type t5;
+
+     public:
+        typedef typename f_::template apply< t1,t2,t3,t4,t5 >::type type;
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind5< F,T1,T2,T3,T4,T5 >,U1, U2, U3, U4, U5
+    >
+{
+    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename f_::template apply< U1,U2,U3,U4,U5 >::type type;
+};
+
+} // namespace aux
+
+BOOST_MPL_AUX_ARITY_SPEC(6, bind5)
+
+// primary template (not a specialization!)
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind
+    : bind5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+template< typename F, typename T >
+struct bind1st
+{
+    template<
+          typename U
+        , typename U2 = void_, typename U3 = void_, typename U4 = void_
+        , typename U5 = void_
+        >
+    struct apply
+        : F::template apply< T,U >
+    {
+    };
+};
+
+template< typename F, typename T >
+struct bind2nd
+{
+    template<
+          typename U
+        , typename U2 = void_, typename U3 = void_, typename U4 = void_
+        , typename U5 = void_
+        >
+    struct apply
+        : F::template apply< U,T >
+    {
+    };
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/fold_backward_impl.hpp

@@ -0,0 +1,223 @@
+// preprocessed version of 'boost/mpl/aux_/fold_backward_impl.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+// forward declaration
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct fold_backward_impl;
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct fold_backward_impl< 0,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef fwd_state0 bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter0 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct fold_backward_impl< 1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply<fwd_state0, typename iter0::type>::type fwd_state1;
+    typedef typename iter0::next iter1;
+    
+
+    typedef fwd_state1 bkwd_state1;
+    typedef typename BackwardOp::template apply<bkwd_state1, typename iter0::type>::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter1 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct fold_backward_impl< 2,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply<fwd_state0, typename iter0::type>::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<fwd_state1, typename iter1::type>::type fwd_state2;
+    typedef typename iter1::next iter2;
+    
+
+    typedef fwd_state2 bkwd_state2;
+    typedef typename BackwardOp::template apply<bkwd_state2, typename iter1::type>::type bkwd_state1;
+    typedef typename BackwardOp::template apply<bkwd_state1, typename iter0::type>::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter2 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct fold_backward_impl< 3,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply<fwd_state0, typename iter0::type>::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<fwd_state1, typename iter1::type>::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply<fwd_state2, typename iter2::type>::type fwd_state3;
+    typedef typename iter2::next iter3;
+    
+
+    typedef fwd_state3 bkwd_state3;
+    typedef typename BackwardOp::template apply<bkwd_state3, typename iter2::type>::type bkwd_state2;
+    typedef typename BackwardOp::template apply<bkwd_state2, typename iter1::type>::type bkwd_state1;
+    typedef typename BackwardOp::template apply<bkwd_state1, typename iter0::type>::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter3 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct fold_backward_impl< 4,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply<fwd_state0, typename iter0::type>::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<fwd_state1, typename iter1::type>::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply<fwd_state2, typename iter2::type>::type fwd_state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply<fwd_state3, typename iter3::type>::type fwd_state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef fwd_state4 bkwd_state4;
+    typedef typename BackwardOp::template apply<bkwd_state4, typename iter3::type>::type bkwd_state3;
+    typedef typename BackwardOp::template apply<bkwd_state3, typename iter2::type>::type bkwd_state2;
+    typedef typename BackwardOp::template apply<bkwd_state2, typename iter1::type>::type bkwd_state1;
+    typedef typename BackwardOp::template apply<bkwd_state1, typename iter0::type>::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter4 iterator;
+};
+
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct fold_backward_impl
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply<fwd_state0, typename iter0::type>::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<fwd_state1, typename iter1::type>::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply<fwd_state2, typename iter2::type>::type fwd_state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply<fwd_state3, typename iter3::type>::type fwd_state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef fold_backward_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , iter4
+        , Last
+        , fwd_state4
+        , BackwardOp
+        , ForwardOp
+        > nested_chunk;
+        
+    typedef typename nested_chunk::state bkwd_state4;
+    typedef typename BackwardOp::template apply<bkwd_state4, typename iter3::type>::type bkwd_state3;
+    typedef typename BackwardOp::template apply<bkwd_state3, typename iter2::type>::type bkwd_state2;
+    typedef typename BackwardOp::template apply<bkwd_state2, typename iter1::type>::type bkwd_state1;
+    typedef typename BackwardOp::template apply<bkwd_state1, typename iter0::type>::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef typename nested_chunk::iterator iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct fold_backward_impl< -1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef fold_backward_impl<
+          -1
+        , typename First::next
+        , Last
+        
+        ,typename ForwardOp::template apply<State, typename First::type>::type
+        , BackwardOp
+        , ForwardOp
+        > nested_step;
+
+    typedef typename BackwardOp::template apply<typename nested_step::state, typename First::type>::type state;
+    typedef typename nested_step::iterator iterator;
+};
+
+template<
+      typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct fold_backward_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp

@@ -0,0 +1,177 @@
+// preprocessed version of 'boost/mpl/aux_/fold_impl.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+// forward declaration
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct fold_impl;
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 0,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef state0 state;
+    typedef iter0 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 1,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply<state0, typename iter0::type>::type state1;
+    typedef typename iter0::next iter1;
+    
+
+    typedef state1 state;
+    typedef iter1 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 2,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply<state0, typename iter0::type>::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<state1, typename iter1::type>::type state2;
+    typedef typename iter1::next iter2;
+    
+
+    typedef state2 state;
+    typedef iter2 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 3,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply<state0, typename iter0::type>::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<state1, typename iter1::type>::type state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply<state2, typename iter2::type>::type state3;
+    typedef typename iter2::next iter3;
+    
+
+    typedef state3 state;
+    typedef iter3 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct fold_impl< 4,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply<state0, typename iter0::type>::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply<state1, typename iter1::type>::type state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply<state2, typename iter2::type>::type state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply<state3, typename iter3::type>::type state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef state4 state;
+    typedef iter4 iterator;
+};
+
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct fold_impl
+{
+    typedef fold_impl<
+          4
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+
+    typedef fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+        
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct fold_impl< -1,First,Last,State,ForwardOp >
+    : fold_impl<
+          -1
+        , typename First::next
+        , Last
+        
+        ,typename ForwardOp::template apply<State, typename First::type>::type
+        , ForwardOp
+        >
+{
+};
+
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct fold_impl< -1,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp

@@ -0,0 +1,582 @@
+// preprocessed version of 'boost/mpl/aux_/full_lambda.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename T
+    , bool Protect = false
+    
+    >
+struct lambda_impl
+{
+    typedef false_ is_le;
+    typedef T type;
+};
+
+template<
+      typename T
+    
+    >
+struct lambda
+    : lambda_impl< T,false >
+{
+};
+
+namespace aux {
+
+template<
+      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
+    , bool C5 = false
+    >
+struct lambda_or
+    : true_
+{
+};
+
+template<>
+struct lambda_or< false,false,false,false,false >
+    : false_
+{
+};
+
+} // namespace aux
+
+template< int N, bool Protect >
+struct lambda_impl< arg<N>,Protect >
+{
+    typedef true_ is_le;
+    typedef arg<N> type;
+};
+
+template<
+      typename F
+    , bool Protect
+    >
+struct lambda_impl<
+      bind0<F>
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind0<
+          F
+        > type;
+};
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    >
+struct lambda< F<T1> >
+    : lambda_impl< F<T1>,true >
+{
+};
+
+namespace aux {
+
+template<
+      bool IsLE
+    , bool Protect
+    , template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1
+{
+    typedef F<
+          typename L1::type
+        > type;
+};
+
+template<
+      template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1< true,false,F,L1 >
+{
+    typedef bind1<
+          quote1<F>
+        , typename L1::type
+        > type;
+};
+
+template<
+      template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1< true,true,F,L1 >
+{
+    typedef protect< bind1<
+          quote1<F>
+        , typename L1::type
+        > > type;
+};
+
+} // namespace aux
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    , bool Protect
+    >
+struct lambda_impl< F<T1>,Protect >
+{
+    typedef lambda_impl<T1> l1;
+    typedef aux::lambda_or<
+          l1::is_le::value
+        > is_le;
+
+    typedef typename aux::le_result1<
+          is_le::value
+        , Protect
+        , F
+        , l1
+        >::type type;
+};
+
+template<
+      typename F, typename T1
+    , bool Protect
+    >
+struct lambda_impl<
+      bind1< F,T1 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind1<
+          F
+        , T1
+        > type;
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    >
+struct lambda< F<T1,T2> >
+    : lambda_impl< F<T1,T2>,true >
+{
+};
+
+namespace aux {
+
+template<
+      bool IsLE
+    , bool Protect
+    , template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2
+{
+    typedef F<
+          typename L1::type, typename L2::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2< true,false,F,L1,L2 >
+{
+    typedef bind2<
+          quote2<F>
+        , typename L1::type, typename L2::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2< true,true,F,L1,L2 >
+{
+    typedef protect< bind2<
+          quote2<F>
+        , typename L1::type, typename L2::type
+        > > type;
+};
+
+} // namespace aux
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    , bool Protect
+    >
+struct lambda_impl< F<T1,T2>,Protect >
+{
+    typedef lambda_impl<T1> l1;
+    typedef lambda_impl<T2> l2;
+    
+    typedef aux::lambda_or<
+          l1::is_le::value, l2::is_le::value
+        > is_le;
+
+    typedef typename aux::le_result2<
+          is_le::value
+        , Protect
+        , F
+        , l1, l2
+        >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2
+    , bool Protect
+    >
+struct lambda_impl<
+      bind2< F,T1,T2 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind2<
+          F
+        , T1, T2
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    >
+struct lambda< F<T1,T2,T3> >
+    : lambda_impl< F<T1,T2,T3>,true >
+{
+};
+
+namespace aux {
+
+template<
+      bool IsLE
+    , bool Protect
+    , template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3< true,false,F,L1,L2,L3 >
+{
+    typedef bind3<
+          quote3<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3< true,true,F,L1,L2,L3 >
+{
+    typedef protect< bind3<
+          quote3<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        > > type;
+};
+
+} // namespace aux
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    , bool Protect
+    >
+struct lambda_impl< F<T1,T2,T3>,Protect >
+{
+    typedef lambda_impl<T1> l1;
+    typedef lambda_impl<T2> l2;
+    typedef lambda_impl<T3> l3;
+    
+    typedef aux::lambda_or<
+          l1::is_le::value, l2::is_le::value, l3::is_le::value
+        > is_le;
+
+    typedef typename aux::le_result3<
+          is_le::value
+        , Protect
+        , F
+        , l1, l2, l3
+        >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    , bool Protect
+    >
+struct lambda_impl<
+      bind3< F,T1,T2,T3 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind3<
+          F
+        , T1, T2, T3
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    >
+struct lambda< F<T1,T2,T3,T4> >
+    : lambda_impl< F<T1,T2,T3,T4>,true >
+{
+};
+
+namespace aux {
+
+template<
+      bool IsLE
+    , bool Protect
+    , template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4< true,false,F,L1,L2,L3,L4 >
+{
+    typedef bind4<
+          quote4<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type
+        > type;
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4< true,true,F,L1,L2,L3,L4 >
+{
+    typedef protect< bind4<
+          quote4<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type
+        > > type;
+};
+
+} // namespace aux
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    , bool Protect
+    >
+struct lambda_impl< F<T1,T2,T3,T4>,Protect >
+{
+    typedef lambda_impl<T1> l1;
+    typedef lambda_impl<T2> l2;
+    typedef lambda_impl<T3> l3;
+    typedef lambda_impl<T4> l4;
+    
+    typedef aux::lambda_or<
+          l1::is_le::value, l2::is_le::value, l3::is_le::value
+        , l4::is_le::value
+        > is_le;
+
+    typedef typename aux::le_result4<
+          is_le::value
+        , Protect
+        , F
+        , l1, l2, l3, l4
+        >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , bool Protect
+    >
+struct lambda_impl<
+      bind4< F,T1,T2,T3,T4 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind4<
+          F
+        , T1, T2, T3, T4
+        > type;
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    >
+struct lambda< F<T1,T2,T3,T4,T5> >
+    : lambda_impl< F<T1,T2,T3,T4,T5>,true >
+{
+};
+
+namespace aux {
+
+template<
+      bool IsLE
+    , bool Protect
+    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type, typename L5::type
+        > type;
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5< true,false,F,L1,L2,L3,L4,L5 >
+{
+    typedef bind5<
+          quote5<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type, typename L5::type
+        > type;
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5< true,true,F,L1,L2,L3,L4,L5 >
+{
+    typedef protect< bind5<
+          quote5<F>
+        , typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type, typename L5::type
+        > > type;
+};
+
+} // namespace aux
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , bool Protect
+    >
+struct lambda_impl< F<T1,T2,T3,T4,T5>,Protect >
+{
+    typedef lambda_impl<T1> l1;
+    typedef lambda_impl<T2> l2;
+    typedef lambda_impl<T3> l3;
+    typedef lambda_impl<T4> l4;
+    typedef lambda_impl<T5> l5;
+    
+    typedef aux::lambda_or<
+          l1::is_le::value, l2::is_le::value, l3::is_le::value
+        , l4::is_le::value, l5::is_le::value
+        > is_le;
+
+    typedef typename aux::le_result5<
+          is_le::value
+        , Protect
+        , F
+        , l1, l2, l3, l4, l5
+        >::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , bool Protect
+    >
+struct lambda_impl<
+      bind5< F,T1,T2,T3,T4,T5 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind5<
+          F
+        , T1, T2, T3, T4, T5
+        > type;
+};
+
+// special case for 'protect'
+template< typename T, bool Protect >
+struct lambda_impl< protect<T>,Protect >
+{
+    typedef false_ is_le;
+    typedef protect<T> type;
+};
+
+// specializations for main 'bind', 'bind1st' and 'bind2nd' forms
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , bool Protect
+    >
+struct lambda_impl<
+      bind< F,T1,T2,T3,T4,T5 >
+    , Protect 
+    >
+{
+    typedef false_ is_le;
+    typedef bind< F,T1,T2,T3,T4,T5 > type;
+};
+
+template<
+      typename F, typename T
+    , bool Protect
+    >
+struct lambda_impl< bind1st<F,T>,Protect >
+{
+    typedef false_ is_le;
+    typedef bind1st< F,T > type;
+};
+
+template<
+      typename F, typename T
+    , bool Protect
+    >
+struct lambda_impl< bind2nd<F,T>,Protect >
+{
+    typedef false_ is_le;
+    typedef bind2nd< F,T > type;
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_backward_impl.hpp

@@ -0,0 +1,222 @@
+// preprocessed version of 'boost/mpl/aux_/iter_fold_backward_impl.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+// forward declaration
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct iter_fold_backward_impl;
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct iter_fold_backward_impl< 0,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef fwd_state0 bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter0 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct iter_fold_backward_impl< 1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply< fwd_state0,iter0 >::type fwd_state1;
+    typedef typename iter0::next iter1;
+    
+
+    typedef fwd_state1 bkwd_state1;
+    typedef typename BackwardOp::template apply< bkwd_state1,iter0 >::type bkwd_state0;
+    typedef bkwd_state0 state;
+    typedef iter1 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct iter_fold_backward_impl< 2,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply< fwd_state0,iter0 >::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< fwd_state1,iter1 >::type fwd_state2;
+    typedef typename iter1::next iter2;
+    
+
+    typedef fwd_state2 bkwd_state2;
+    typedef typename BackwardOp::template apply< bkwd_state2,iter1 >::type bkwd_state1;
+    typedef typename BackwardOp::template apply< bkwd_state1,iter0 >::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter2 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct iter_fold_backward_impl< 3,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply< fwd_state0,iter0 >::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< fwd_state1,iter1 >::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply< fwd_state2,iter2 >::type fwd_state3;
+    typedef typename iter2::next iter3;
+    
+
+    typedef fwd_state3 bkwd_state3;
+    typedef typename BackwardOp::template apply< bkwd_state3,iter2 >::type bkwd_state2;
+    typedef typename BackwardOp::template apply< bkwd_state2,iter1 >::type bkwd_state1;
+    typedef typename BackwardOp::template apply< bkwd_state1,iter0 >::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter3 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    >
+struct iter_fold_backward_impl< 4,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply< fwd_state0,iter0 >::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< fwd_state1,iter1 >::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply< fwd_state2,iter2 >::type fwd_state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply< fwd_state3,iter3 >::type fwd_state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef fwd_state4 bkwd_state4;
+    typedef typename BackwardOp::template apply< bkwd_state4,iter3 >::type bkwd_state3;
+    typedef typename BackwardOp::template apply< bkwd_state3,iter2 >::type bkwd_state2;
+    typedef typename BackwardOp::template apply< bkwd_state2,iter1 >::type bkwd_state1;
+    typedef typename BackwardOp::template apply< bkwd_state1,iter0 >::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef iter4 iterator;
+};
+
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct iter_fold_backward_impl
+{
+    typedef First iter0;
+    typedef State fwd_state0;
+    typedef typename ForwardOp::template apply< fwd_state0,iter0 >::type fwd_state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< fwd_state1,iter1 >::type fwd_state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply< fwd_state2,iter2 >::type fwd_state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply< fwd_state3,iter3 >::type fwd_state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef iter_fold_backward_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , iter4
+        , Last
+        , fwd_state4
+        , BackwardOp
+        , ForwardOp
+        > nested_chunk;
+        
+    typedef typename nested_chunk::state bkwd_state4;
+    typedef typename BackwardOp::template apply< bkwd_state4,iter3 >::type bkwd_state3;
+    typedef typename BackwardOp::template apply< bkwd_state3,iter2 >::type bkwd_state2;
+    typedef typename BackwardOp::template apply< bkwd_state2,iter1 >::type bkwd_state1;
+    typedef typename BackwardOp::template apply< bkwd_state1,iter0 >::type bkwd_state0;
+    
+
+    typedef bkwd_state0 state;
+    typedef typename nested_chunk::iterator iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct iter_fold_backward_impl< -1,First,Last,State,BackwardOp,ForwardOp >
+{
+    typedef iter_fold_backward_impl<
+          -1
+        , typename First::next
+        , Last
+        , typename ForwardOp::template apply< State,First >::type
+        , BackwardOp
+        , ForwardOp
+        > nested_step;
+
+    typedef typename BackwardOp::template apply<typename nested_step::state, First>::type state;
+    typedef typename nested_step::iterator iterator;
+};
+
+template<
+      typename Last
+    , typename State
+    , typename BackwardOp
+    , typename ForwardOp
+    > 
+struct iter_fold_backward_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp

@@ -0,0 +1,129 @@
+// preprocessed version of 'boost/mpl/aux_/iter_fold_if_impl.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+template< typename Iterator, typename State >
+struct iter_fold_if_null_step
+{
+    typedef State state;
+    typedef Iterator iterator;
+};
+
+template< bool >
+struct iter_fold_if_step_impl
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef typename StateOp::template apply< State,Iterator >::type state;
+        typedef typename IteratorOp::type iterator;
+    };
+};
+
+template<>
+struct iter_fold_if_step_impl<false>
+{
+    template<
+          typename Iterator
+        , typename State
+        , typename StateOp
+        , typename IteratorOp
+        >
+    struct result_
+    {
+        typedef State state;
+        typedef Iterator iterator;
+    };
+};
+
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_forward_step
+{
+    typedef typename Predicate::template apply< State,Iterator >::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value
+        >::template result_< Iterator,State,ForwardOp,next<Iterator> > impl_;
+
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+
+template<
+      typename Iterator
+    , typename State
+    , typename BackwardOp
+    , typename Predicate
+    >
+struct iter_fold_if_backward_step
+{
+    typedef typename Predicate::template apply< State,Iterator >::type not_last;
+    typedef typename iter_fold_if_step_impl<
+          BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value
+        >::template result_< Iterator,State,BackwardOp,identity<Iterator> > impl_;
+
+    typedef typename impl_::state state;
+    typedef typename impl_::iterator iterator;
+};
+
+template<
+      typename Iterator
+    , typename State
+    , typename ForwardOp
+    , typename ForwardPredicate
+    , typename BackwardOp
+    , typename BackwardPredicate
+    >
+struct iter_fold_if_impl
+{
+ private:
+    typedef iter_fold_if_null_step< Iterator,State > forward_step0;
+    typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1;
+    typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2;
+    typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3;
+    typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4;
+    
+    
+    typedef typename if_<
+          typename forward_step4::not_last
+        , iter_fold_if_impl<
+              typename forward_step4::iterator
+            , typename forward_step4::state
+            , ForwardOp
+            , ForwardPredicate
+            , BackwardOp
+            , BackwardPredicate
+            >
+        , iter_fold_if_null_step<
+              typename forward_step4::iterator
+            , typename forward_step4::state
+            >
+        >::type backward_step4;
+
+    typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3;
+    typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2;
+    typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1;
+    typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0;
+    
+
+ public:
+    typedef typename backward_step0::state state;
+    typedef typename backward_step4::iterator iterator;
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp

@@ -0,0 +1,176 @@
+// preprocessed version of 'boost/mpl/aux_/iter_fold_impl.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+namespace aux {
+
+// forward declaration
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct iter_fold_impl;
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 0,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef state0 state;
+    typedef iter0 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 1,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply< state0,iter0 >::type state1;
+    typedef typename iter0::next iter1;
+    
+
+    typedef state1 state;
+    typedef iter1 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 2,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply< state0,iter0 >::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< state1,iter1 >::type state2;
+    typedef typename iter1::next iter2;
+    
+
+    typedef state2 state;
+    typedef iter2 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 3,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply< state0,iter0 >::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< state1,iter1 >::type state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply< state2,iter2 >::type state3;
+    typedef typename iter2::next iter3;
+    
+
+    typedef state3 state;
+    typedef iter3 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 4,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename ForwardOp::template apply< state0,iter0 >::type state1;
+    typedef typename iter0::next iter1;
+    typedef typename ForwardOp::template apply< state1,iter1 >::type state2;
+    typedef typename iter1::next iter2;
+    typedef typename ForwardOp::template apply< state2,iter2 >::type state3;
+    typedef typename iter2::next iter3;
+    typedef typename ForwardOp::template apply< state3,iter3 >::type state4;
+    typedef typename iter3::next iter4;
+    
+
+    typedef state4 state;
+    typedef iter4 iterator;
+};
+
+template<
+      long N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct iter_fold_impl
+{
+    typedef iter_fold_impl<
+          4
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+
+    typedef iter_fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+        
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct iter_fold_impl< -1,First,Last,State,ForwardOp >
+    : iter_fold_impl<
+          -1
+        , typename First::next
+        , Last
+        , typename ForwardOp::template apply< State,First >::type
+        , ForwardOp
+        >
+{
+};
+
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    > 
+struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+} // namespace aux
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/lambda_helper.hpp

@@ -0,0 +1,120 @@
+// preprocessed version of 'boost/mpl/lambda_helper.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    >
+struct lambda_helper1
+{
+    struct rebind
+    {
+        static int const arity = 1;
+        typedef T1 arg1;
+
+        template< typename U1 > struct apply
+            : F<U1>
+        {
+        };
+   };
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    >
+struct lambda_helper2
+{
+    struct rebind
+    {
+        static int const arity = 2;
+        typedef T1 arg1;
+        typedef T2 arg2;
+        
+        template< typename U1, typename U2 > struct apply
+            : F< U1,U2 >
+        {
+        };
+   };
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    >
+struct lambda_helper3
+{
+    struct rebind
+    {
+        static int const arity = 3;
+        typedef T1 arg1;
+        typedef T2 arg2;
+        typedef T3 arg3;
+        
+        template< typename U1, typename U2, typename U3 > struct apply
+            : F< U1,U2,U3 >
+        {
+        };
+   };
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    >
+struct lambda_helper4
+{
+    struct rebind
+    {
+        static int const arity = 4;
+        typedef T1 arg1;
+        typedef T2 arg2;
+        typedef T3 arg3;
+        typedef T4 arg4;
+        
+        template<
+              typename U1, typename U2, typename U3, typename U4
+            >
+        struct apply
+            : F< U1,U2,U3,U4 >
+        {
+        };
+   };
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    >
+struct lambda_helper5
+{
+    struct rebind
+    {
+        static int const arity = 5;
+        typedef T1 arg1;
+        typedef T2 arg2;
+        typedef T3 arg3;
+        typedef T4 arg4;
+        typedef T5 arg5;
+        
+        template<
+              typename U1, typename U2, typename U3, typename U4
+            , typename U5
+            >
+        struct apply
+            : F< U1,U2,U3,U4,U5 >
+        {
+        };
+   };
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp

@@ -0,0 +1,160 @@
+// preprocessed version of 'boost/mpl/lambda_no_ctps.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+namespace aux {
+
+template< int arity_, bool Protect > struct lambda_impl
+{
+    template< typename T > struct result_
+    {
+        typedef T type;
+    };
+};
+
+template<> struct lambda_impl<1, false>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef bind1<
+              f_
+            , typename lambda< typename F::arg1, false >::type
+            > type;
+    };
+};
+
+template<> struct lambda_impl<1, true>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef protect< bind1<
+              f_
+            , typename lambda< typename F::arg1, false >::type
+            > > type;
+    };
+};
+
+template<> struct lambda_impl<2, false>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef bind2<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type
+            > type;
+    };
+};
+
+template<> struct lambda_impl<2, true>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef protect< bind2<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type
+            > > type;
+    };
+};
+
+template<> struct lambda_impl<3, false>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef bind3<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type
+            > type;
+    };
+};
+
+template<> struct lambda_impl<3, true>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef protect< bind3<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type
+            > > type;
+    };
+};
+
+template<> struct lambda_impl<4, false>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef bind4<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type, typename lambda< typename F::arg4, false >::type
+            > type;
+    };
+};
+
+template<> struct lambda_impl<4, true>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef protect< bind4<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type, typename lambda< typename F::arg4, false >::type
+            > > type;
+    };
+};
+
+template<> struct lambda_impl<5, false>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef bind5<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type, typename lambda< typename F::arg4, false >::type, typename lambda< typename F::arg5, false >::type
+            > type;
+    };
+};
+
+template<> struct lambda_impl<5, true>
+{
+    template< typename F > struct result_
+    {
+        typedef typename F::rebind f_;
+        typedef protect< bind5<
+              f_
+            
+            ,typename lambda< typename F::arg1, false >::type, typename lambda< typename F::arg2, false >::type, typename lambda< typename F::arg3, false >::type, typename lambda< typename F::arg4, false >::type, typename lambda< typename F::arg5, false >::type
+            > > type;
+    };
+};
+
+} // namespace aux
+
+template< typename T, bool Protect = true >
+struct lambda
+    : aux::lambda_impl<
+          ::boost::mpl::aux::template_arity<T>::value
+
+        , Protect
+
+        >::template result_<T>
+{
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/list.hpp

@@ -0,0 +1,129 @@
+// preprocessed version of 'boost/mpl/list.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename T0 = void_, typename T1 = void_, typename T2 = void_
+    , typename T3 = void_, typename T4 = void_, typename T5 = void_
+    , typename T6 = void_, typename T7 = void_, typename T8 = void_
+    , typename T9 = void_
+    >
+struct list;
+
+template<
+      
+    >
+struct list<
+          void_, void_, void_, void_, void_, void_, void_, void_, void_
+        , void_
+        >
+    : list0<  >
+{
+    typedef list0<  > type;
+};
+
+template<
+      typename T0
+    >
+struct list<
+          T0, void_, void_, void_, void_, void_, void_, void_, void_, void_
+        >
+    : list1<T0>
+{
+    typedef list1<T0> type;
+};
+
+template<
+      typename T0, typename T1
+    >
+struct list<
+          T0, T1, void_, void_, void_, void_, void_, void_, void_, void_
+        >
+    : list2< T0,T1 >
+{
+    typedef list2< T0,T1 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2
+    >
+struct list< T0,T1,T2,void_,void_,void_,void_,void_,void_,void_ >
+    : list3< T0,T1,T2 >
+{
+    typedef list3< T0,T1,T2 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct list< T0,T1,T2,T3,void_,void_,void_,void_,void_,void_ >
+    : list4< T0,T1,T2,T3 >
+{
+    typedef list4< T0,T1,T2,T3 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct list< T0,T1,T2,T3,T4,void_,void_,void_,void_,void_ >
+    : list5< T0,T1,T2,T3,T4 >
+{
+    typedef list5< T0,T1,T2,T3,T4 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct list< T0,T1,T2,T3,T4,T5,void_,void_,void_,void_ >
+    : list6< T0,T1,T2,T3,T4,T5 >
+{
+    typedef list6< T0,T1,T2,T3,T4,T5 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct list< T0,T1,T2,T3,T4,T5,T6,void_,void_,void_ >
+    : list7< T0,T1,T2,T3,T4,T5,T6 >
+{
+    typedef list7< T0,T1,T2,T3,T4,T5,T6 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct list< T0,T1,T2,T3,T4,T5,T6,T7,void_,void_ >
+    : list8< T0,T1,T2,T3,T4,T5,T6,T7 >
+{
+    typedef list8< T0,T1,T2,T3,T4,T5,T6,T7 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct list< T0,T1,T2,T3,T4,T5,T6,T7,T8,void_ >
+    : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+{
+    typedef list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > type;
+};
+
+// primary template (not a specialization!)
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct list
+    : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+{
+    typedef list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > type;
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp

@@ -0,0 +1,151 @@
+// preprocessed version of 'boost/mpl/list_c.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename T
+    , long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX
+    , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX
+    , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX
+    , long C9 = LONG_MAX
+    >
+struct list_c;
+
+template<
+      typename T
+     
+    >
+struct list_c<
+          T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : list0_c<T>
+{
+    typedef typename list0_c<T>::type type;
+};
+
+template<
+      typename T
+    , long C0
+    >
+struct list_c<
+          T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : list1_c< T,C0 >
+{
+    typedef typename list1_c< T,C0 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1
+    >
+struct list_c<
+          T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : list2_c< T,C0,C1 >
+{
+    typedef typename list2_c< T,C0,C1 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2
+    >
+struct list_c<
+          T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX
+        >
+    : list3_c< T,C0,C1,C2 >
+{
+    typedef typename list3_c< T,C0,C1,C2 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3
+    >
+struct list_c<
+          T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX
+        >
+    : list4_c< T,C0,C1,C2,C3 >
+{
+    typedef typename list4_c< T,C0,C1,C2,C3 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4
+    >
+struct list_c<
+          T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX
+        >
+    : list5_c< T,C0,C1,C2,C3,C4 >
+{
+    typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5
+    >
+struct list_c<
+          T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : list6_c< T,C0,C1,C2,C3,C4,C5 >
+{
+    typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6
+    >
+struct list_c< T,C0,C1,C2,C3,C4,C5,C6,LONG_MAX,LONG_MAX,LONG_MAX >
+    : list7_c< T,C0,C1,C2,C3,C4,C5,C6 >
+{
+    typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    >
+struct list_c< T,C0,C1,C2,C3,C4,C5,C6,C7,LONG_MAX,LONG_MAX >
+    : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >
+{
+    typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    , long C8
+    >
+struct list_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,LONG_MAX >
+    : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >
+{
+    typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type;
+};
+
+// primary template (not a specialization!)
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    , long C8, long C9
+    >
+struct list_c
+    : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >
+{
+    typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type;
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/or.hpp

@@ -0,0 +1,62 @@
+// preprocessed version of 'boost/mpl/aux_/config/use_preprocessed.hpp' header
+// see the original for copyright information
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct or_impl
+    : true_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct or_impl< false,T1,T2,T3,T4 >
+    : or_impl<
+          BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value
+        , T2, T3, T4
+        , false_
+        >
+{
+};
+
+template<>
+struct or_impl<
+          false
+        , false_, false_, false_, false_
+        >
+    : false_
+{
+};
+
+} // namespace aux
+
+template<
+      typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T1)
+    , typename BOOST_MPL_AUX_VOID_SPEC_PARAM(T2)
+    , typename T3 = false_, typename T4 = false_, typename T5 = false_
+    >
+struct or_
+
+    : aux::or_impl<
+          BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value
+        , T2, T3, T4, T5
+        >
+
+{
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(
+          5
+        , or_
+        , (T1, T2, T3, T4, T5)
+        )
+};
+
+BOOST_MPL_AUX_VOID_SPEC_EXT(
+      2
+    , 5
+    , or_
+    )
+
+}} // namespace boost::mpl
+

include/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp

@@ -0,0 +1,54 @@
+// preprocessed version of 'boost/mpl/aux_/config/use_preprocessed.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+typedef arg< -1 > _;
+
+namespace placeholders {
+using boost::mpl::_;
+}
+
+// agurt, 17/mar/02: one more placeholder for the last 'apply#' 
+// specialization
+
+typedef arg<1> _1;
+
+namespace placeholders {
+using boost::mpl::_1;
+}
+
+typedef arg<2> _2;
+
+namespace placeholders {
+using boost::mpl::_2;
+}
+
+typedef arg<3> _3;
+
+namespace placeholders {
+using boost::mpl::_3;
+}
+
+typedef arg<4> _4;
+
+namespace placeholders {
+using boost::mpl::_4;
+}
+
+typedef arg<5> _5;
+
+namespace placeholders {
+using boost::mpl::_5;
+}
+
+typedef arg<6> _6;
+
+namespace placeholders {
+using boost::mpl::_6;
+}
+
+} // namespace mpl
+} // namespace boost 
+

include/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp

@@ -0,0 +1,3 @@
+// preprocessed version of 'boost/mpl/quote.hpp' header
+// see the original for copyright information
+

include/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp

@@ -0,0 +1,33 @@
+// preprocessed version of 'boost/mpl/aux_/template_arity.hpp' header
+// see the original for copyright information
+
+namespace boost { namespace mpl { namespace aux {
+
+template< bool >
+struct template_arity_impl
+{
+    template< typename F > struct result_
+    {
+        static int const value = -1;
+    };
+};
+
+template<>
+struct template_arity_impl<true>
+{
+    template< typename F > struct result_
+    {
+        static int const value = F::arity;
+
+    };
+};
+
+template< typename F >
+struct template_arity
+    : template_arity_impl< ::boost::mpl::aux::has_rebind<F>::value >
+        ::template result_<F>
+{
+};
+
+}}} // namespace boost::mpl::aux
+

include/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp

@@ -0,0 +1,129 @@
+// preprocessed version of 'boost/mpl/vector.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename T0 = void_, typename T1 = void_, typename T2 = void_
+    , typename T3 = void_, typename T4 = void_, typename T5 = void_
+    , typename T6 = void_, typename T7 = void_, typename T8 = void_
+    , typename T9 = void_
+    >
+struct vector;
+
+template<
+      
+    >
+struct vector<
+          void_, void_, void_, void_, void_, void_, void_, void_, void_
+        , void_
+        >
+    : vector0<  >
+{
+    typedef vector0<  > type;
+};
+
+template<
+      typename T0
+    >
+struct vector<
+          T0, void_, void_, void_, void_, void_, void_, void_, void_, void_
+        >
+    : vector1<T0>
+{
+    typedef vector1<T0> type;
+};
+
+template<
+      typename T0, typename T1
+    >
+struct vector<
+          T0, T1, void_, void_, void_, void_, void_, void_, void_, void_
+        >
+    : vector2< T0,T1 >
+{
+    typedef vector2< T0,T1 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2
+    >
+struct vector< T0,T1,T2,void_,void_,void_,void_,void_,void_,void_ >
+    : vector3< T0,T1,T2 >
+{
+    typedef vector3< T0,T1,T2 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct vector< T0,T1,T2,T3,void_,void_,void_,void_,void_,void_ >
+    : vector4< T0,T1,T2,T3 >
+{
+    typedef vector4< T0,T1,T2,T3 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct vector< T0,T1,T2,T3,T4,void_,void_,void_,void_,void_ >
+    : vector5< T0,T1,T2,T3,T4 >
+{
+    typedef vector5< T0,T1,T2,T3,T4 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct vector< T0,T1,T2,T3,T4,T5,void_,void_,void_,void_ >
+    : vector6< T0,T1,T2,T3,T4,T5 >
+{
+    typedef vector6< T0,T1,T2,T3,T4,T5 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct vector< T0,T1,T2,T3,T4,T5,T6,void_,void_,void_ >
+    : vector7< T0,T1,T2,T3,T4,T5,T6 >
+{
+    typedef vector7< T0,T1,T2,T3,T4,T5,T6 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct vector< T0,T1,T2,T3,T4,T5,T6,T7,void_,void_ >
+    : vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
+{
+    typedef vector8< T0,T1,T2,T3,T4,T5,T6,T7 > type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct vector< T0,T1,T2,T3,T4,T5,T6,T7,T8,void_ >
+    : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+{
+    typedef vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > type;
+};
+
+// primary template (not a specialization!)
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct vector
+    : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+{
+    typedef vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > type;
+};
+
+} // namespace mpl
+} // namespace boost
+

include/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp

@@ -0,0 +1,153 @@
+// preprocessed version of 'boost/mpl/vector_c.hpp' header
+// see the original for copyright information
+
+namespace boost {
+namespace mpl {
+
+template<
+      typename T
+    , long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX
+    , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX
+    , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX
+    , long C9 = LONG_MAX
+    >
+struct vector_c;
+
+template<
+      typename T
+     
+    >
+struct vector_c<
+          T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : vector0_c<T>
+{
+    typedef vector0_c<T> type;
+};
+
+template<
+      typename T
+    , long C0
+    >
+struct vector_c<
+          T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : vector1_c< T,C0 >
+{
+    typedef vector1_c< T,C0 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1
+    >
+struct vector_c<
+          T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : vector2_c< T,C0,C1 >
+{
+    typedef vector2_c< T,C0,C1 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2
+    >
+struct vector_c<
+          T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX, LONG_MAX
+        >
+    : vector3_c< T,C0,C1,C2 >
+{
+    typedef vector3_c< T,C0,C1,C2 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3
+    >
+struct vector_c<
+          T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX
+        >
+    : vector4_c< T,C0,C1,C2,C3 >
+{
+    typedef vector4_c< T,C0,C1,C2,C3 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4
+    >
+struct vector_c<
+          T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        , LONG_MAX
+        >
+    : vector5_c< T,C0,C1,C2,C3,C4 >
+{
+    typedef vector5_c< T,C0,C1,C2,C3,C4 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5
+    >
+struct vector_c<
+          T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : vector6_c< T,C0,C1,C2,C3,C4,C5 >
+{
+    typedef vector6_c< T,C0,C1,C2,C3,C4,C5 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6
+    >
+struct vector_c<
+          T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX
+        >
+    : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >
+{
+    typedef vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    >
+struct vector_c< T,C0,C1,C2,C3,C4,C5,C6,C7,LONG_MAX,LONG_MAX >
+    : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >
+{
+    typedef vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > type;
+};
+
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    , long C8
+    >
+struct vector_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,LONG_MAX >
+    : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >
+{
+    typedef vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > type;
+};
+
+// primary template (not a specialization!)
+template<
+      typename T
+    , long C0, long C1, long C2, long C3, long C4, long C5, long C6, long C7
+    , long C8, long C9
+    >
+struct vector_c
+    : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >
+{
+    typedef vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > type;
+};
+
+} // namespace mpl
+} // namespace boost
+