Resolve BOOST_PP_ITERATE() macro includes in boost/proto

14 files changed, 2509 insertions, 0 deletions

diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/callable_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/callable_eval.hpp
new file mode 100644
index 0000000000..abe7803b0b
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/callable_eval.hpp
@@ -0,0 +1,113 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/context/detail/preprocessed/callable_eval.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_CHILD_N_TYPE(Z, N, Expr)                                                    \
+        typedef typename proto::result_of::child_c<Expr const &, N>::type BOOST_PP_CAT(child, N);   \
+        /**/
+
+    #define BOOST_PROTO_CHILD_N(Z, N, expr)                                                         \
+        proto::child_c<N>(expr)                                                                     \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/callable_eval.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file callable_eval.hpp
+    /// Contains specializations of the callable_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/callable_eval.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_CHILD_N_TYPE
+    #undef BOOST_PROTO_CHILD_N
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, N>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, sexpr_)
+                        ), 0)
+                    )
+                );
+
+            typedef mpl::bool_<value> type;
+        };
+    }
+
+    namespace context
+    {
+        /// \brief A BinaryFunction that accepts a Proto expression and a
+        /// callable context and calls the context with the expression tag
+        /// and children as arguments, effectively fanning the expression
+        /// out.
+        ///
+        /// <tt>callable_eval\<\></tt> requires that \c Context is a
+        /// PolymorphicFunctionObject that can be invoked with \c Expr's
+        /// tag and children as expressions, as follows:
+        ///
+        /// \code
+        /// context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)
+        /// \endcode
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, N>
+        {
+            BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD_N_TYPE, Expr)
+
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        BOOST_PP_ENUM_TRAILING_PARAMS(N, child)
+                    )
+                >::type
+            result_type;
+
+            /// \param expr The current expression
+            /// \param context The callable evaluation context
+            /// \return <tt>context(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr), ...)</tt>
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_CHILD_N, expr)
+                );
+            }
+        };
+    }
+
+    #undef N
+
+#endif
diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/default_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/default_eval.hpp
new file mode 100644
index 0000000000..980427604e
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/default_eval.hpp
@@ -0,0 +1,82 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/context/detail/preprocessed/default_eval.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_DEFAULT_EVAL_SHIFTED(Z, M, DATA)                                            \
+        BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)                                       \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_eval.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file default_eval.hpp
+    /// Contains specializations of the default_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/default_eval.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEFAULT_EVAL_SHIFTED
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, N>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
+            >::type
+        function_type;
+
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr))
+            >::type
+        result_type;
+
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(
+                BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, expr)
+            );
+        }
+
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, expr))) ->*
+                BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)
+            )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEFAULT_EVAL_SHIFTED, expr));
+        }
+    };
+
+    #undef N
+
+#endif
diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/null_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/null_eval.hpp
new file mode 100644
index 0000000000..dcf0077af3
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/null_eval.hpp
@@ -0,0 +1,54 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/context/detail/preprocessed/null_eval.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_EVAL_N(Z, N, DATA)                                                          \
+        proto::eval(proto::child_c<N>(expr), ctx);                                                  \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/null_eval.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file null_eval.hpp
+    /// Contains specializations of the null_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/context/detail/null_eval.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_EVAL_N
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, N>
+    {
+        typedef void result_type;
+
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            BOOST_PP_REPEAT(N, BOOST_PROTO_EVAL_N, ~)
+        }
+    };
+
+    #undef N
+
+#endif
diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/callable_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/callable_eval.hpp
new file mode 100644
index 0000000000..5b32c8f469
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/callable_eval.hpp
@@ -0,0 +1,597 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file callable_eval.hpp
+    /// Contains specializations of the callable_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 1>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 1>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 2>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 2>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 3>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 3>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 4>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 4>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 5>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 5>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 6>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 6>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 7>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 7>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 8>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 8>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 9>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 9>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr)
+                );
+            }
+        };
+    }
+    namespace detail
+    {
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 10>
+        {
+            static callable_context_wrapper<Context> &sctx_;
+            static Expr &sexpr_;
+            static typename Expr::proto_tag &stag_;
+            static const bool value =
+                sizeof(yes_type) ==
+                sizeof(
+                    detail::check_is_expr_handled(
+                        (sctx_(
+                            stag_
+                            , proto::child_c< 0>( sexpr_) , proto::child_c< 1>( sexpr_) , proto::child_c< 2>( sexpr_) , proto::child_c< 3>( sexpr_) , proto::child_c< 4>( sexpr_) , proto::child_c< 5>( sexpr_) , proto::child_c< 6>( sexpr_) , proto::child_c< 7>( sexpr_) , proto::child_c< 8>( sexpr_) , proto::child_c< 9>( sexpr_)
+                        ), 0)
+                    )
+                );
+            typedef mpl::bool_<value> type;
+        };
+    }
+    namespace context
+    {
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 10>
+        {
+            typedef typename proto::result_of::child_c< Expr const &, 0>::type child0; typedef typename proto::result_of::child_c< Expr const &, 1>::type child1; typedef typename proto::result_of::child_c< Expr const &, 2>::type child2; typedef typename proto::result_of::child_c< Expr const &, 3>::type child3; typedef typename proto::result_of::child_c< Expr const &, 4>::type child4; typedef typename proto::result_of::child_c< Expr const &, 5>::type child5; typedef typename proto::result_of::child_c< Expr const &, 6>::type child6; typedef typename proto::result_of::child_c< Expr const &, 7>::type child7; typedef typename proto::result_of::child_c< Expr const &, 8>::type child8; typedef typename proto::result_of::child_c< Expr const &, 9>::type child9;
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(
+                        typename Expr::proto_tag
+                        , child0 , child1 , child2 , child3 , child4 , child5 , child6 , child7 , child8 , child9
+                    )
+                >::type
+            result_type;
+            
+            
+            
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(
+                    typename Expr::proto_tag()
+                    , proto::child_c< 0>( expr) , proto::child_c< 1>( expr) , proto::child_c< 2>( expr) , proto::child_c< 3>( expr) , proto::child_c< 4>( expr) , proto::child_c< 5>( expr) , proto::child_c< 6>( expr) , proto::child_c< 7>( expr) , proto::child_c< 8>( expr) , proto::child_c< 9>( expr)
+                );
+            }
+        };
+    }
diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/default_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/default_eval.hpp
new file mode 100644
index 0000000000..ebc69ce062
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/default_eval.hpp
@@ -0,0 +1,279 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file default_eval.hpp
+    /// Contains specializations of the default_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 3>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 4>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 5>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 6>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 7>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 8>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 9>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context));
+        }
+    };
+    template<typename Expr, typename Context>
+    struct default_eval<Expr, Context, proto::tag::function, 10>
+    {
+        typedef
+            typename proto::detail::result_of_fixup<
+                typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 0>::type >::type , Context >::type
+            >::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 1>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 2>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 3>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 4>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 5>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 6>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 7>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 8>::type >::type , Context >::type , typename proto::result_of::eval< typename remove_reference< typename proto::result_of::child_c< Expr, 9>::type >::type , Context >::type)
+            >::type
+        result_type;
+        result_type operator ()(Expr &expr, Context &context) const
+        {
+            return this->invoke(expr, context, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(Expr &expr, Context &context, mpl::false_) const
+        {
+            return proto::eval(proto::child_c< 0>( expr), context)(
+                proto::eval(proto::child_c< 1>( expr), context) , proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context)
+            );
+        }
+        result_type invoke(Expr &expr, Context &context, mpl::true_) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (proto::eval(proto::child_c< 1>( expr), context))) ->*
+                proto::eval(proto::child_c< 0>( expr), context)
+            )(proto::eval(proto::child_c< 2>( expr), context) , proto::eval(proto::child_c< 3>( expr), context) , proto::eval(proto::child_c< 4>( expr), context) , proto::eval(proto::child_c< 5>( expr), context) , proto::eval(proto::child_c< 6>( expr), context) , proto::eval(proto::child_c< 7>( expr), context) , proto::eval(proto::child_c< 8>( expr), context) , proto::eval(proto::child_c< 9>( expr), context));
+        }
+    };
diff --git a/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/null_eval.hpp b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/null_eval.hpp
new file mode 100644
index 0000000000..e124408cfa
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/context/detail/preprocessed/null_eval.hpp
@@ -0,0 +1,97 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file null_eval.hpp
+    /// Contains specializations of the null_eval\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 1>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 2>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 3>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 4>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 5>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 6>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 7>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 8>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 9>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx);
+        }
+    };
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 10>
+    {
+        typedef void result_type;
+        void operator ()(Expr &expr, Context &ctx) const
+        {
+            proto::eval(proto::child_c< 0>(expr), ctx); proto::eval(proto::child_c< 1>(expr), ctx); proto::eval(proto::child_c< 2>(expr), ctx); proto::eval(proto::child_c< 3>(expr), ctx); proto::eval(proto::child_c< 4>(expr), ctx); proto::eval(proto::child_c< 5>(expr), ctx); proto::eval(proto::child_c< 6>(expr), ctx); proto::eval(proto::child_c< 7>(expr), ctx); proto::eval(proto::child_c< 8>(expr), ctx); proto::eval(proto::child_c< 9>(expr), ctx);
+        }
+    };
diff --git a/contrib/restricted/boost/proto/include/boost/proto/detail/class_member_traits.hpp b/contrib/restricted/boost/proto/include/boost/proto/detail/class_member_traits.hpp
new file mode 100644
index 0000000000..98d8ebbf48
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/detail/class_member_traits.hpp
@@ -0,0 +1,51 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/class_member_traits.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/class_member_traits.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // class_member_traits.hpp
+    // Contains specializations of the class_member_traits\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/class_member_traits.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A))>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+
+    template<typename T, typename U BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct class_member_traits<T (U::*)(BOOST_PP_ENUM_PARAMS(N, A)) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
diff --git a/contrib/restricted/boost/proto/include/boost/proto/detail/memfun_funop.hpp b/contrib/restricted/boost/proto/include/boost/proto/detail/memfun_funop.hpp
new file mode 100644
index 0000000000..8a63a9f5c3
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/detail/memfun_funop.hpp
@@ -0,0 +1,45 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/memfun_funop.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/memfun_funop.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // memfun_funop.hpp
+    // Contains overloads of memfun::operator().
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/memfun_funop.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+    BOOST_FORCEINLINE
+    result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(BOOST_PP_ENUM_PARAMS(N, a));
+    }
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
diff --git a/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/class_member_traits.hpp b/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/class_member_traits.hpp
new file mode 100644
index 0000000000..418957a9c6
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/class_member_traits.hpp
@@ -0,0 +1,139 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // class_member_traits.hpp
+    // Contains specializations of the class_member_traits\<\> class template.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    template<typename T, typename U >
+    struct class_member_traits<T (U::*)()>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U >
+    struct class_member_traits<T (U::*)() const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0>
+    struct class_member_traits<T (U::*)(A0)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0>
+    struct class_member_traits<T (U::*)(A0) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1>
+    struct class_member_traits<T (U::*)(A0 , A1)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1>
+    struct class_member_traits<T (U::*)(A0 , A1) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
+    template<typename T, typename U , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct class_member_traits<T (U::*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const>
+    {
+        typedef U class_type;
+        typedef T result_type;
+    };
diff --git a/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/memfun_funop.hpp b/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/memfun_funop.hpp
new file mode 100644
index 0000000000..3449160c36
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/detail/preprocessed/memfun_funop.hpp
@@ -0,0 +1,77 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // memfun_funop.hpp
+    // Contains overloads of memfun::operator().
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    template<typename A0>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0);
+    }
+    template<typename A0 , typename A1>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1);
+    }
+    template<typename A0 , typename A1 , typename A2>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    BOOST_FORCEINLINE
+    result_type operator()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9) const
+    {
+        BOOST_PROTO_USE_GET_POINTER();
+        return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
diff --git a/contrib/restricted/boost/proto/include/boost/proto/transform/detail/default_function_impl.hpp b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/default_function_impl.hpp
new file mode 100644
index 0000000000..a8f421c095
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/default_function_impl.hpp
@@ -0,0 +1,97 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/transform/detail/preprocessed/default_function_impl.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_DEF_FUN_INVOKE_ARG(Z, M, DATA)                                              \
+        BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_function_impl.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file default_function_impl.hpp
+    /// Contains definition of the default_function_impl, the implementation of the
+    /// _default transform for function-like nodes.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/default_function_impl.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEF_FUN_INVOKE_ARG
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, N>
+      : transform_impl<Expr, State, Data>
+    {
+        BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)
+
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r))
+            >::type
+        result_type;
+
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(
+                BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e)
+            );
+        }
+
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (BOOST_PROTO_DEFAULT_EVAL(~, 1, e))) ->* 
+                BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
+            )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEF_FUN_INVOKE_ARG, e));
+        }
+    };
+
+    #undef N
+
+#endif
diff --git a/contrib/restricted/boost/proto/include/boost/proto/transform/detail/lazy.hpp b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/lazy.hpp
new file mode 100644
index 0000000000..fbd13651cf
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/lazy.hpp
@@ -0,0 +1,79 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/transform/detail/preprocessed/lazy.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lazy.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file lazy.hpp
+    /// Contains definition of the lazy<> transform.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                             \
+        (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/lazy.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
+    /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
+    ///
+    /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
+    /// transform to be applied depends on the current state of the
+    /// transformation. The invocation of the <tt>make\<\></tt> transform
+    /// evaluates any nested transforms, and the resulting type is treated
+    /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
+    template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))>
+      : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (BOOST_PP_ENUM_PARAMS(N, A))
+            >::template impl<Expr, State, Data>
+        {};
+    };
+
+    #if N > 0
+    template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)>
+      : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A)...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , BOOST_PP_CAT(A, BOOST_PP_DEC(N))
+                  , detail::BOOST_PP_CAT(expand_pattern_rest_, BOOST_PP_DEC(N))<
+                        Object
+                        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_DEC(N), A)
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    #endif
+
+    #undef N
+
+#endif
diff --git a/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/default_function_impl.hpp b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/default_function_impl.hpp
new file mode 100644
index 0000000000..72ff60e80f
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/default_function_impl.hpp
@@ -0,0 +1,392 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file default_function_impl.hpp
+    /// Contains definition of the default_function_impl, the implementation of the
+    /// _default transform for function-like nodes.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 3>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 4>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 5>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 6>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4 , r5)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 7>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 8>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 9>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ));
+        }
+    };
+    template<typename Grammar, typename Expr, typename State, typename Data>
+    struct default_function_impl<Grammar, Expr, State, Data, 10>
+      : transform_impl<Expr, State, Data>
+    {
+        typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, State, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9;
+        typedef
+            typename proto::detail::result_of_fixup<r0>::type
+        function_type;
+        typedef
+            typename BOOST_PROTO_RESULT_OF<
+                function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9)
+            >::type
+        result_type;
+        result_type operator ()(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+        ) const
+        {
+            return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+        }
+    private:
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::false_
+        ) const
+        {
+            return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+                typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )
+            );
+        }
+        result_type invoke(
+            typename default_function_impl::expr_param e
+          , typename default_function_impl::state_param s
+          , typename default_function_impl::data_param d
+          , mpl::true_
+        ) const
+        {
+            BOOST_PROTO_USE_GET_POINTER();
+            typedef typename detail::class_member_traits<function_type>::class_type class_type;
+            return (
+                BOOST_PROTO_GET_POINTER(class_type, (typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) ->* 
+                typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+            )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ));
+        }
+    };
diff --git a/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/lazy.hpp b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/lazy.hpp
new file mode 100644
index 0000000000..c32d20fa25
--- /dev/null
+++ b/contrib/restricted/boost/proto/include/boost/proto/transform/detail/preprocessed/lazy.hpp
@@ -0,0 +1,407 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file lazy.hpp
+    /// Contains definition of the lazy<> transform.
+    //
+    //  Copyright 2008 Eric Niebler. Distributed under the Boost
+    //  Software License, Version 1.0. (See accompanying file
+    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object >
+    struct lazy<Object()>
+      : transform<lazy<Object()> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                ()
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0>
+    struct lazy<Object(A0)>
+      : transform<lazy<Object(A0)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0>
+    struct lazy<Object(A0...)>
+      : transform<lazy<Object(A0...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A0
+                  , detail::expand_pattern_rest_0<
+                        Object
+                        
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1>
+    struct lazy<Object(A0 , A1)>
+      : transform<lazy<Object(A0 , A1)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1>
+    struct lazy<Object(A0 , A1...)>
+      : transform<lazy<Object(A0 , A1...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A1
+                  , detail::expand_pattern_rest_1<
+                        Object
+                        , A0
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct lazy<Object(A0 , A1 , A2)>
+      : transform<lazy<Object(A0 , A1 , A2)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2>
+    struct lazy<Object(A0 , A1 , A2...)>
+      : transform<lazy<Object(A0 , A1 , A2...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A2
+                  , detail::expand_pattern_rest_2<
+                        Object
+                        , A0 , A1
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct lazy<Object(A0 , A1 , A2 , A3)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+    struct lazy<Object(A0 , A1 , A2 , A3...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A3
+                  , detail::expand_pattern_rest_3<
+                        Object
+                        , A0 , A1 , A2
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A4
+                  , detail::expand_pattern_rest_4<
+                        Object
+                        , A0 , A1 , A2 , A3
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A5
+                  , detail::expand_pattern_rest_5<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A6
+                  , detail::expand_pattern_rest_6<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A7
+                  , detail::expand_pattern_rest_7<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A8
+                  , detail::expand_pattern_rest_8<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : call<
+                typename make<Object>::template impl<Expr, State, Data>::result_type
+                (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)
+            >::template impl<Expr, State, Data>
+        {};
+    };
+    template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)>
+      : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9...)> >
+    {
+        template<typename Expr, typename State, typename Data>
+        struct impl
+          : lazy<
+                typename detail::expand_pattern<
+                    proto::arity_of<Expr>::value
+                  , A9
+                  , detail::expand_pattern_rest_9<
+                        Object
+                        , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+                    >
+                >::type
+            >::template impl<Expr, State, Data>
+        {};
+    };