#ifndef BOOST_PP_IS_ITERATING
    #ifndef BOOST_LAMBDA_HPP_EAN_04_19_2008
    #define BOOST_LAMBDA_HPP_EAN_04_19_2008

    #define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 10
    #define BOOST_PROTO_MAX_ARITY 10
    #define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY 5

    #include <iosfwd>
    #include <typeinfo>
    #include <algorithm>
    #include <boost/ref.hpp>
    #include <boost/assert.hpp>
    #include <boost/mpl/or.hpp>
    #include <boost/mpl/int.hpp>
    #include <boost/mpl/void.hpp>
    #include <boost/mpl/identity.hpp>
    #include <boost/mpl/next_prior.hpp>
    #include <boost/mpl/min_max.hpp>
    #include <boost/mpl/assert.hpp>
    #include <boost/mpl/apply_wrap.hpp>
    #include <boost/preprocessor.hpp>
    #include <boost/utility/enable_if.hpp>
    #include <boost/utility/result_of.hpp>
    #include <boost/fusion/include/vector.hpp>
    #include <boost/type_traits/add_reference.hpp>
    #include <boost/type_traits/remove_reference.hpp>
    #include <boost/type_traits/remove_const.hpp>
    #include <boost/type_traits/is_same.hpp>
    #include <boost/type_traits/is_abstract.hpp>
    #include <boost/type_traits/is_array.hpp>
    #include <boost/type_traits/is_function.hpp>
    #include <boost/proto/proto.hpp>

    #ifndef BOOST_LAMBDA_MAX_ARITY
    # define BOOST_LAMBDA_MAX_ARITY 3
    #endif

    #ifdef _MSC_VER
    # pragma warning(push)
    # pragma warning(disable: 4355) // 'this' : used in base member initializer list
    # pragma warning(disable: 4065) // switch statement contains 'default' but no 'case' labels
    #endif

    namespace boost { namespace lambda
    {
        namespace tag
        {
            struct if_ {};
            struct if_else_ {};
            struct for_ {};
            struct while_ {};
            struct do_while_ {};
            struct protect {};
            struct try_ {};
            struct throw_ {};
            struct rethrow_ {};
            struct switch_ {};
            struct default_ {};
            template<int I> struct case_ { BOOST_STATIC_CONSTANT(int, value = I); };
            template<typename E> struct catch_ { typedef E exception_type; };
            struct catch_all_ { typedef catch_all_ exception_type; };
        };

        template<typename Int>
        struct placeholder
        {
            typedef typename Int::tag tag;
            typedef typename Int::value_type value_type;
            typedef placeholder<Int> type;
            typedef placeholder<typename Int::next> next;
            typedef placeholder<typename Int::prior> prior;
            BOOST_STATIC_CONSTANT(value_type, value = Int::value);

            friend std::ostream &operator<<(std::ostream &sout, placeholder)
            {
                return sout << "boost::lambda::_" << (Int::value+1);
            }
        };

        struct exception_placeholder
        {};

        struct no_exception_type {};
        no_exception_type const no_exception = {};

        // Calculate the arity of a lambda expression
        struct Arity
          : proto::or_<
                proto::when<proto::terminal<placeholder<proto::_> >, mpl::next<proto::_value>()>
              , proto::when<proto::terminal<proto::_>, mpl::int_<0>()>
              , proto::otherwise<proto::fold<proto::_, mpl::int_<0>(), mpl::max<proto::_state, Arity>()> >
            >
        {};

        // True when a lambda expression can be applied with no arguments and
        // without an active exception object
        struct IsNullary
          : proto::or_<
                proto::when<proto::terminal<placeholder<proto::_> >, mpl::false_()>
              , proto::when<proto::terminal<exception_placeholder>, mpl::false_()>
              , proto::when<proto::terminal<proto::_>, mpl::true_()>
              , proto::otherwise<proto::fold<proto::_, mpl::true_(), mpl::and_<proto::_state, IsNullary>()> >
            >
        {};
        
        struct at : proto::callable
        {
            template<class Sig>
            struct result;

            template<class This, class Cont, class Int>
            struct result<This(Cont, Int)>
              : fusion::result_of::at<
                    typename remove_reference<Cont>::type
                  , typename remove_reference<Int>::type
                >
            {};

            template<typename Cont, typename Int>
            typename fusion::result_of::at<Cont, Int>::type
            operator ()(Cont &cont, Int const &) const
            {
                return fusion::at<Int>(cont);
            }
        };

        struct Eval;

        struct EvalWhile : proto::transform<EvalWhile>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef mpl::void_ result_type;

                result_type operator()(
                    typename impl::expr_param expr
                  , typename impl::state_param state
                  , typename impl::data_param data
                ) const
                {
                    while(Eval()(proto::left(expr), state, data))
                    {
                        Eval()(proto::right(expr), state, data);
                    }
                    return result_type();
                }
            };
        };

        struct EvalDoWhile : proto::transform<EvalDoWhile>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef mpl::void_ result_type;

                result_type operator()(
                    typename impl::expr_param expr
                  , typename impl::state_param state
                  , typename impl::data_param data
                ) const
                {
                    do
                    {
                        Eval()(proto::child_c<0>(expr), state, data);
                    }
                    while(Eval()(proto::child_c<1>(expr), state, data));

                    return result_type();
                }
            };
        };

        struct EvalFor : proto::transform<EvalFor>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef mpl::void_ result_type;

                result_type operator()(
                    typename impl::expr_param expr
                  , typename impl::state_param state
                  , typename impl::data_param data
                ) const
                {
                    for(Eval()(proto::child_c<0>(expr), state, data)
                      ; Eval()(proto::child_c<1>(expr), state, data)
                      ; Eval()(proto::child_c<2>(expr), state, data))
                    {
                        Eval()(proto::child_c<3>(expr), state, data);
                    }
                    return result_type();
                }
            };
        };

        struct EvalIf : proto::transform<EvalIf>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef mpl::void_ result_type;

                result_type operator()(
                    typename impl::expr_param expr
                  , typename impl::state_param state
                  , typename impl::data_param data
                ) const
                {
                    if(Eval()(proto::left(expr), state, data))
                    {
                        Eval()(proto::right(expr), state, data);
                    }
                    return result_type();
                }
            };
        };

        struct EvalIfElse : proto::transform<EvalIfElse>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef mpl::void_ result_type;

                result_type operator()(
                    typename impl::expr_param expr
                  , typename impl::state_param state
                  , typename impl::data_param data
                ) const
                {
                    if(Eval()(proto::child_c<0>(expr), state, data))
                    {
                        Eval()(proto::child_c<1>(expr), state, data);
                    }
                    else
                    {
                        Eval()(proto::child_c<2>(expr), state, data);
                    }
                    return result_type();
                }
            };
        };

        struct EvalException : proto::transform<EvalException>
        {
            template<typename Expr, typename State, typename Data>
            struct impl : proto::transform_impl<Expr, State, Data>
            {
                typedef typename remove_const<typename impl::state>::type result_type;
                BOOST_MPL_ASSERT_NOT((is_same<result_type, no_exception_type>));
                BOOST_MPL_ASSERT_NOT((is_same<result_type, tag::catch_all_>));

                typename impl::state_param operator()(
                    typename impl::expr_param
                  , typename impl::state_param state
                  , typename impl::data_param
                ) const
                {
                    return state;
                }
            };
        };

        struct EvalSwitch : proto::transform<EvalSwitch>
        {
            template<typename Expr, typename State, typename Data, long Arity, typename BackTag>
            struct impl2;
            
            #define M0(Z, N, DATA)                                                                  \
                case proto::tag_of<typename proto::result_of::child_c<Expr, N>::type>::type::value: \
                    Eval()(proto::child_c<N>(expr), state, data);                                   \
                    break;                                                                          \
                    /**/

            #define M1(Z, N, DATA)                                                                  \
            template<typename Expr, typename State, typename Data, typename BackTag>                \
            struct impl2<Expr, State, Data, N, BackTag>                                             \
              : proto::transform_impl<Expr, State, Data>                                            \
            {                                                                                       \
                typedef void result_type;                                                           \
                                                                                                    \
                void operator()(                                                                    \
                    typename impl2::expr_param expr                                                 \
                  , typename impl2::state_param state                                               \
                  , typename impl2::data_param data                                                 \
                ) const                                                                             \
                {                                                                                   \
                    switch(Eval()(proto::child_c<0>(expr), state, data))                            \
                    {                                                                               \
                        BOOST_PP_REPEAT_FROM_TO_ ## Z(1, N, M0, ~)                                  \
                    default:                                                                        \
                        break;                                                                      \
                    }                                                                               \
                }                                                                                   \
            };                                                                                      \
                                                                                                    \
            template<typename Expr, typename State, typename Data>                                  \
            struct impl2<Expr, State, Data, N, tag::default_>                                       \
              : proto::transform_impl<Expr, State, Data>                                            \
            {                                                                                       \
                typedef void result_type;                                                           \
                                                                                                    \
                void operator()(                                                                    \
                    typename impl2::expr_param expr                                                 \
                  , typename impl2::state_param state                                               \
                  , typename impl2::data_param data                                                 \
                ) const                                                                             \
                {                                                                                   \
                    switch(Eval()(proto::child_c<0>(expr), state, data))                            \
                    {                                                                               \
                        BOOST_PP_REPEAT_FROM_TO_ ## Z(1, BOOST_PP_DEC(N), M0, ~)                    \
                    default:;                                                                       \
                        Eval()(proto::child_c<BOOST_PP_DEC(N)>(expr), state, data);                 \
                        break;                                                                      \
                    }                                                                               \
                }                                                                                   \
            };                                                                                      \
            /**/
            BOOST_PP_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1, ~)
            #undef M0
            #undef M1

            template<typename Expr, typename State, typename Data>
            struct impl
              : impl2<
                    Expr
                  , State
                  , Data
                  , proto::arity_of<Expr>::value
                  , typename proto::tag_of<
                        typename proto::result_of::child_c<
                            Expr
                          , proto::arity_of<Expr>::value-1
                        >::type
                    >::type
                >
            {};
        };

        struct throw_fun
        {
            BOOST_PROTO_CALLABLE()
            typedef void result_type;
            template<typename Expr>
            void operator()(Expr const &e) const
            {
                throw e;
            }
        };
        
        struct unwrap_ref : proto::callable
        {
            template<typename Sig>
            struct result;
            
            template<typename This, typename T>
            struct result<This(reference_wrapper<T>)>
            {
                typedef T &type;                
            };
            
            template<typename This, typename T>
            struct result<This(T &)>
              : result<This(T)>
            {};
            
            template<typename T>
            T &operator()(reference_wrapper<T> const &ref) const
            {
                return ref;
            }
        };

        struct anytype
        {
            template<typename T>
            anytype(T &) { BOOST_ASSERT(false); }
            template<typename T>
            operator T &() const { BOOST_ASSERT(false); throw; }
        private:
            anytype();
        };

        struct rethrow_fun
        {
            BOOST_PROTO_CALLABLE()
            typedef anytype result_type;
            template<typename State>
            anytype operator()(State const &) const
            {
                BOOST_MPL_ASSERT_NOT((is_same<State, no_exception_type>));
                throw;
            }
        };

        struct Cases
        {
            template<typename Tag>
            struct case_
              : proto::otherwise<proto::_default<Eval> >
            {};

            template<typename E>
            struct case_<tag::catch_<E> >
              : proto::otherwise<Eval(proto::_child)>
            {};

            template<int I>
            struct case_<tag::case_<I> >
              : proto::otherwise<Eval(proto::_child)>
            {};
        };

        template<> struct Cases::case_<tag::while_>     : proto::otherwise<EvalWhile> {};
        template<> struct Cases::case_<tag::for_>       : proto::otherwise<EvalFor> {};
        template<> struct Cases::case_<tag::if_>        : proto::otherwise<EvalIf> {};
        template<> struct Cases::case_<tag::if_else_>   : proto::otherwise<EvalIfElse> {};
        template<> struct Cases::case_<tag::do_while_>  : proto::otherwise<EvalDoWhile> {};
        template<> struct Cases::case_<tag::switch_>    : proto::otherwise<EvalSwitch> {};
        template<> struct Cases::case_<tag::protect>    : proto::otherwise<proto::_child> {};
        template<> struct Cases::case_<tag::default_>   : proto::otherwise<Eval(proto::_child)> {};
        template<> struct Cases::case_<tag::catch_all_> : proto::otherwise<Eval(proto::_child)> {};

        template<>
        struct Cases::case_<proto::tag::terminal>
          : proto::or_<
                proto::when<
                    proto::terminal<placeholder<proto::_> >
                  , at(proto::_data, proto::_value)
                >
              , proto::when<
                    proto::terminal<exception_placeholder>
                  , EvalException
                >
              , proto::when<
                    proto::terminal<reference_wrapper<proto::_> >
                  , unwrap_ref(proto::_value)
                >
              , proto::otherwise<proto::_default<Eval> >
            >
        {};

        template<>
        struct Cases::case_<proto::tag::function>
          : proto::or_<
                proto::when<
                    proto::function<proto::terminal<rethrow_fun> >
                  , rethrow_fun(proto::_state)
                >
              , proto::otherwise<proto::_default<Eval> >
            >
        {};

        struct Eval
          : proto::switch_<Cases>
        {};

        // Use a grammar to disable Proto's assignment operator overloads.
        // We'll define our own because we want (x+=_1) to store x by
        // reference. (In all other cases, variables are stored by value
        // within lambda expressions.)
        struct Grammar
          : proto::switch_<struct AssignOps>
        {};

        struct AssignOps
        {
            template<typename Tag> struct case_ : proto::_ {};
        };

        template<> struct AssignOps::case_<proto::tag::shift_left_assign>   : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::shift_right_assign>  : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::multiplies_assign>   : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::divides_assign>      : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::modulus_assign>      : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::plus_assign>         : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::minus_assign>        : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::bitwise_and_assign>  : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::bitwise_or_assign>   : proto::not_<proto::_> {};
        template<> struct AssignOps::case_<proto::tag::bitwise_xor_assign>  : proto::not_<proto::_> {};

        namespace exprns_
        {
            template<typename Expr>
            struct llexpr;
        }

        using exprns_::llexpr;

        template<typename T>
        struct is_stream
        {
        private:
            static T &t;
            typedef char yes_type;
            typedef char (&no_type)[2];
            static no_type test_is_stream(...);
            template<typename Char, typename Traits>
            static yes_type test_is_stream(std::basic_istream<Char, Traits> &);
            template<typename Char, typename Traits>
            static yes_type test_is_stream(std::basic_ostream<Char, Traits> &);
        public:
            typedef bool value_type;
            BOOST_STATIC_CONSTANT(bool, value = sizeof(yes_type) == sizeof(test_is_stream(t)));
            typedef mpl::bool_<value> type;
        };

        // These terminal types are always stored by reference
        template<typename Value>
        struct store_by_ref
          : mpl::or_<
                is_abstract<Value>
              , is_array<Value>
              , is_function<Value>
              , is_stream<Value>
            >
        {};

        // Wrap expressions in lambda::llexpr<>, and hold children nodes
        // and some terminal types by value.
        struct Generator
          : proto::or_<
                proto::when<
                    proto::and_<
                        proto::terminal<proto::_>
                      , proto::if_<store_by_ref<proto::_value>()>
                    >
                  , proto::pod_generator<llexpr>(proto::_)
                >
              , proto::otherwise<
                    proto::compose_generators<
                        proto::by_value_generator
                      , proto::pod_generator<llexpr>
                    >(proto::_)
                >
            >
        {};

        struct lldomain
          : proto::domain<Generator, Grammar>
        {};

        template<typename Sig>
        struct llresult;

        template<typename This>
        struct llresult<This()>
          : mpl::if_c<
                result_of<IsNullary(This &)>::type::value
              , result_of<Eval(This &, no_exception_type const &, fusion::vector0 &)>
              , mpl::identity<void>
            >::type
        {};

        #define M0(Z, N, DATA)                                                                      \
        template<typename This BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, typename A)>                   \
        struct llresult<This(BOOST_PP_ENUM_PARAMS_Z(Z, N, A))>                                      \
          : result_of<                                                                              \
                Eval(                                                                               \
                    This &                                                                          \
                  , no_exception_type const &                                                       \
                  , BOOST_PP_CAT(fusion::vector, N)<BOOST_PP_ENUM_PARAMS_Z(Z, N, A)> &              \
                )                                                                                   \
            >                                                                                       \
        {};                                                                                         \
        /**/
        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_LAMBDA_MAX_ARITY), M0, ~)
        #undef M0

        template<typename Expr>
        struct llexpr
        {
            BOOST_PROTO_BASIC_EXTENDS(Expr, llexpr<Expr>, lldomain)
            BOOST_PROTO_EXTENDS_ASSIGN()
            BOOST_PROTO_EXTENDS_SUBSCRIPT()

            template<typename Sig>
            struct result
              : llresult<Sig>
            {};

            typename result<llexpr const()>::type
            operator()() const
            {
                fusion::vector0 args;
                return Eval()(*this, no_exception, args);
            }

            #define M1(Z, N, _) ((0)(1))

            #define M2(R, PRODUCT) M3(R, BOOST_PP_SEQ_SIZE(PRODUCT), PRODUCT)

            #define M3(R, SIZE, PRODUCT)                                                                    \
                template<BOOST_PP_ENUM_PARAMS(SIZE, typename A)>                                            \
                typename result<llexpr const(BOOST_PP_SEQ_FOR_EACH_I_R(R, M5, ~, PRODUCT))>::type           \
                operator ()(BOOST_PP_SEQ_FOR_EACH_I_R(R, M4, ~, PRODUCT)) const                             \
                {                                                                                           \
                    BOOST_MPL_ASSERT_RELATION(result_of<Arity(Expr const &)>::type::value, <=, SIZE);       \
                    BOOST_PP_CAT(fusion::vector, SIZE)<BOOST_PP_SEQ_FOR_EACH_I_R(R, M5, ~, PRODUCT)> args   \
                        (BOOST_PP_SEQ_FOR_EACH_I_R(R, M6, ~, PRODUCT));                                     \
                    return Eval()(*this, no_exception, args);                                               \
                }                                                                                           \
                /**/

            #define M4(R, _, I, ELEM)                                                                       \
                BOOST_PP_COMMA_IF(I) BOOST_PP_CAT(A, I) BOOST_PP_CAT(C, ELEM) &BOOST_PP_CAT(a, I)           \
                /**/

            #define M5(R, _, I, ELEM)                                                                       \
                BOOST_PP_COMMA_IF(I) BOOST_PP_CAT(A, I) BOOST_PP_CAT(C, ELEM)&                              \
                /**/

            #define M6(R, _, I, ELEM)                                                                       \
                BOOST_PP_COMMA_IF(I) BOOST_PP_CAT(a, I)                                                     \
                /**/

            #define C0

            #define C1 const

            #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_LAMBDA_MAX_ARITY, "./lambda.hpp"))
            #include BOOST_PP_ITERATE()

            #undef C0
            #undef C1
            #undef M1
            #undef M2
            #undef M3
            #undef M4
            #undef M5
            #undef M6
        };

        typedef llexpr<proto::terminal<placeholder<mpl::int_<0> > >::type> placeholder1_type;
        typedef llexpr<proto::terminal<placeholder<mpl::int_<1> > >::type> placeholder2_type;
        typedef llexpr<proto::terminal<placeholder<mpl::int_<2> > >::type> placeholder3_type;

        placeholder1_type const _1 = {{{}}};
        placeholder2_type const _2 = {{{}}};
        placeholder3_type const _3 = {{{}}};

        placeholder1_type const free1 = {{{}}};
        placeholder2_type const free2 = {{{}}};
        placeholder3_type const free3 = {{{}}};

        typedef llexpr<proto::terminal<exception_placeholder>::type> placeholderE_type;
        placeholderE_type const _e = {{{}}};

        struct byref
        {
            template<typename Sig>
            struct result;
            
            template<typename This, typename T>
            struct result<This(T &)>
            {
                typedef llexpr<typename proto::terminal<T &>::type> type;
            };

            template<typename This, typename T>
            struct result<This(llexpr<T> &)>
            {
                typedef boost::reference_wrapper<llexpr<T> > type;
            };

            template<typename This, typename T>
            struct result<This(llexpr<T> const &)>
            {
                typedef boost::reference_wrapper<llexpr<T> const> type;
            };

            template<typename T>
            typename result<byref(T &)>::type operator()(T &t) const
            {
                typename result<byref(T &)>::type that = {{t}};
                return that;
            }

            template<typename T>
            typename result<byref(T const &)>::type operator()(T const &t) const
            {
                typename result<byref(T const &)>::type that = {{t}};
                return that;
            }

            template<typename T>
            boost::reference_wrapper<llexpr<T> > operator()(llexpr<T> &t) const
            {
                return boost::ref(t);
            }

            template<typename T>
            boost::reference_wrapper<llexpr<T> const> operator()(llexpr<T> const &t) const
            {
                return boost::ref(t);
            }
        };

        namespace exprns_
        {
            // Ugh, the assign operators (and only the assign operators) store
            // their left terminals by reference. That requires this special handling.
            #define BOOST_LAMBDA_DEFINE_ASSIGN_OP(OP, TAG)                                          \
            template<typename T, typename U>                                                        \
            typename proto::result_of::make_expr<                                                   \
                TAG                                                                                 \
              , lldomain                                                                            \
              , typename boost::result_of<byref(T &)>::type                                         \
              , U &                                                                                 \
            >::type const                                                                           \
            operator OP(T &t, U &u)                                                                 \
            {                                                                                       \
                return proto::make_expr<TAG, lldomain>(byref()(t), boost::ref(u));                  \
            }                                                                                       \
            template<typename T, typename U>                                                        \
            typename proto::result_of::make_expr<                                                   \
                TAG                                                                                 \
              , lldomain                                                                            \
              , typename boost::result_of<byref(T &)>::type                                         \
              , U const &                                                                           \
            >::type const                                                                           \
            operator OP(T &t, U const &u)                                                           \
            {                                                                                       \
                return proto::make_expr<TAG, lldomain>(byref()(t), boost::ref(u));                  \
            }                                                                                       \
            /**/

            BOOST_LAMBDA_DEFINE_ASSIGN_OP(<<=, boost::proto::tag::shift_left_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(>>=, boost::proto::tag::shift_right_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(*= , boost::proto::tag::multiplies_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(/= , boost::proto::tag::divides_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(%= , boost::proto::tag::modulus_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(+= , boost::proto::tag::plus_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(-= , boost::proto::tag::minus_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(&= , boost::proto::tag::bitwise_and_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(|= , boost::proto::tag::bitwise_or_assign)
            BOOST_LAMBDA_DEFINE_ASSIGN_OP(^= , boost::proto::tag::bitwise_xor_assign)
        }

        template<typename T>
        struct var_type
        {
            typedef llexpr<typename proto::terminal<T &>::type> type;
        };
        
        template<typename T>
        llexpr<typename proto::terminal<T &>::type> const
        var(T &t)
        {
            llexpr<typename proto::terminal<T &>::type> that = {{t}};
            return that;
        }

        template<typename T>
        struct constant_type
          : proto::result_of::make_expr<
                proto::tag::terminal
              , lldomain
              , T const &
            >
        {};

        template<typename T>
        typename constant_type<T>::type const
        constant(T const &t)
        {
            typename constant_type<T>::type that = {{t}};
            return that;
        }

        template<typename T>
        struct constant_ref_type
        {
            typedef llexpr<typename proto::terminal<T const &>::type> type;
        };
        
        template<typename T>
        llexpr<typename proto::terminal<T const &>::type> const
        constant_ref(T const &t)
        {
            llexpr<typename proto::terminal<T const &>::type> that = {{t}};
            return that;
        }

        template<typename Cond>
        struct while_generator
        {
            explicit while_generator(Cond const &c)
              : cond(c)
            {}

            template<typename Body>
            typename proto::result_of::make_expr<
                tag::while_
              , lldomain
              , Cond const &
              , Body const &
            >::type const
            operator[](Body const &body) const
            {
                return proto::make_expr<tag::while_, lldomain>(
                    boost::ref(this->cond)
                  , boost::ref(body)
                );
            }

        private:
            Cond const &cond;
        };

        template<typename Expr>
        while_generator<Expr> while_(Expr const &expr)
        {
            return while_generator<Expr>(expr);
        }

        template<typename Expr>
        struct else_generator
        {
            typedef typename proto::result_of::left<Expr const &>::type condition_type;
            typedef typename proto::result_of::right<Expr const &>::type body1_type;

            explicit else_generator(Expr const &expr)
              : if_(expr)
            {}

            template<typename Body2>
            typename proto::result_of::make_expr<
                tag::if_else_
              , lldomain
              , condition_type
              , body1_type
              , Body2 const &
            >::type const
            operator[](Body2 const &body2) const
            {
                return proto::make_expr<tag::if_else_, lldomain>(
                    boost::ref(proto::left(this->if_))
                  , boost::ref(proto::right(this->if_))
                  , boost::ref(body2)
                );
            }

        private:
            Expr const &if_;
        };

        template<typename Expr>
        struct with_else : Expr
        {
            template<typename T>
            with_else(T const &expr)
              : Expr(expr)
              , else_(*this)
            {}

            else_generator<Expr> else_;
        };

        template<typename Cond>
        struct if_generator
        {
            explicit if_generator(Cond const &c)
              : cond(c)
            {}

            template<typename Body>
            with_else<
                typename proto::result_of::make_expr<
                    tag::if_
                  , lldomain
                  , Cond const &
                  , Body const &
                >::type
            > const
            operator[](Body const &body) const
            {
                return proto::make_expr<tag::if_, lldomain>(
                    boost::ref(this->cond)
                  , boost::ref(body)
                );
            }

        private:
            Cond const &cond;
        };

        template<typename Expr>
        if_generator<Expr> if_(Expr const &expr)
        {
            return if_generator<Expr>(expr);
        }

        template<typename Init, typename Cond, typename Oper>
        struct for_generator
        {
            explicit for_generator(Init const &i, Cond const &c, Oper const &o)
              : init(i)
              , cond(c)
              , oper(o)
            {}

            template<typename Body>
            typename proto::result_of::make_expr<
                tag::for_
              , lldomain
              , Init const &
              , Cond const &
              , Oper const &
              , Body const &
            >::type const
            operator[](Body const &body) const
            {
                return proto::make_expr<tag::for_, lldomain>(
                    boost::ref(this->init)
                  , boost::ref(this->cond)
                  , boost::ref(this->oper)
                  , boost::ref(body)
                );
            }

        private:
            Init const &init;
            Cond const &cond;
            Oper const &oper;
        };

        template<typename Init, typename Cond, typename Oper>
        for_generator<Init, Cond, Oper> for_(Init const &i, Cond const &c, Oper const &o)
        {
            return for_generator<Init, Cond, Oper>(i, c, o);
        }

        template<typename Body>
        struct do_while_generator
        {
            explicit do_while_generator(Body const &b)
              : body(b)
            {}

            template<typename Cond>
            typename proto::result_of::make_expr<
                tag::do_while_
              , lldomain
              , Body const &
              , Cond const &
            >::type const
            operator()(Cond const &cond) const
            {
                return proto::make_expr<tag::do_while_, lldomain>(
                    boost::ref(this->body)
                  , boost::ref(cond)
                );
            }

        private:
            Body const &body;
        };

        template<typename Body>
        struct do_body
        {
            explicit do_body(Body const &body)
              : while_(body)
            {}

            do_while_generator<Body> while_;
        };

        struct do_generator
        {
            template<typename Body>
            do_body<Body> operator[](Body const &body) const
            {
                return do_body<Body>(body);
            }
        };

        do_generator const do_ = {};

        struct noop_fun
        {
            typedef void result_type;
            void operator()() const {}
        };

        typedef llexpr<proto::function<llexpr<proto::terminal<noop_fun>::type> >::type> noop_type;
        noop_type const noop = {{{{{}}}}};

        template<typename Init, typename Cond, typename Oper>
        typename proto::result_of::make_expr<
            tag::for_
          , lldomain
          , Init const &
          , Cond const &
          , Oper const &
          , noop_type const &
        >::type const
        for_loop(Init const &init, Cond const &cond, Oper const &oper)
        {
            return proto::make_expr<tag::for_, lldomain>(
                boost::ref(init)
              , boost::ref(cond)
              , boost::ref(oper)
              , boost::ref(noop)
            );
        }

        template<typename Init, typename Cond, typename Oper, typename Body>
        typename proto::result_of::make_expr<
            tag::for_
          , lldomain
          , Init const &
          , Cond const &
          , Oper const &
          , Body const &
        >::type const
        for_loop(Init const &init, Cond const &cond, Oper const &oper, Body const &body)
        {
            return proto::make_expr<tag::for_>(
                boost::ref(init)
              , boost::ref(cond)
              , boost::ref(oper)
              , boost::ref(body)
            );
        }

        template<typename Cond, typename Body>
        typename proto::result_of::make_expr<
            tag::while_
          , lldomain
          , Cond const &
          , Body const &
        >::type const
        while_loop(Cond const &cond, Body const &body)
        {
            return proto::make_expr<tag::while_, lldomain>(
                boost::ref(cond)
              , boost::ref(body)
            );
        }

        template<typename Cond>
        typename proto::result_of::make_expr<
            tag::while_
          , lldomain
          , Cond const &
          , noop_type const &
        >::type const
        while_loop(Cond const &cond)
        {
            return proto::make_expr<tag::while_, lldomain>(
                boost::ref(cond)
              , boost::ref(noop)
            );
        }

        template<typename Cond, typename Body>
        typename proto::result_of::make_expr<
            tag::do_while_
          , lldomain
          , Body const &
          , Cond const &
        >::type const
        do_while_loop(Cond const &cond, Body const &body)
        {
            return proto::make_expr<tag::do_while_, lldomain>(
                boost::ref(body)
              , boost::ref(cond)
            );
        }

        template<typename Cond>
        typename proto::result_of::make_expr<
            tag::do_while_
          , lldomain
          , noop_type const &
          , Cond const &
        >::type const
        do_while_loop(Cond const &cond)
        {
            return proto::make_expr<tag::do_while_, lldomain>(
                boost::ref(noop)
              , boost::ref(cond)
            );
        }

        template<typename Cond, typename Body1>
        typename proto::result_of::make_expr<
            tag::if_
          , lldomain
          , Cond const &
          , Body1 const &
        >::type const
        if_then(Cond const &cond, Body1 const &body1)
        {
            return proto::make_expr<tag::if_, lldomain>(
                boost::ref(cond)
              , boost::ref(body1)
            );
        }

        template<typename Cond, typename Body1, typename Body2>
        typename proto::result_of::make_expr<
            tag::if_else_
          , lldomain
          , Cond const &
          , Body1 const &
          , Body2 const &
        >::type const
        if_then_else(Cond const &cond, Body1 const &body1, Body2 const &body2)
        {
            return proto::make_expr<tag::if_else_, lldomain>(
                boost::ref(cond)
              , boost::ref(body1)
              , boost::ref(body2)
            );
        }

        template<typename Cond, typename Body1, typename Body2>
        typename proto::result_of::make_expr<
            proto::tag::if_else_
          , lldomain
          , Cond const &
          , Body1 const &
          , Body2 const &
        >::type const
        if_then_else_return(Cond const &cond, Body1 const &body1, Body2 const &body2)
        {
            return proto::make_expr<proto::tag::if_else_, lldomain>(
                boost::ref(cond)
              , boost::ref(body1)
              , boost::ref(body2)
            );
        }

        template<typename T>
        T const &make_const(T const &t)
        {
            return t;
        }
        
        #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a)                                \
        template<typename_A(N)>                                                                     \
        typename proto::result_of::make_expr<                                                       \
            proto::tag::function                                                                    \
          , lldomain                                                                                \
          , A_const_ref(N)                                                                          \
        >::type const                                                                               \
        bind(A_const_ref_a(N))                                                                      \
        {                                                                                           \
            return proto::make_expr<proto::tag::function, lldomain>(ref_a(N));                      \
        }                                                                                           \
                                                                                                    \
        template<typename Ret, typename_A(N)>                                                       \
        typename proto::result_of::make_expr<                                                       \
            proto::tag::function                                                                    \
          , lldomain                                                                                \
          , A_const_ref(N)                                                                          \
        >::type const                                                                               \
        bind(A_const_ref_a(N))                                                                      \
        {                                                                                           \
            return proto::make_expr<proto::tag::function, lldomain>(ref_a(N));                      \
        }                                                                                           \
        /**/
        BOOST_PROTO_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
        #undef M1

        template<typename Ret, typename Expr>
        Expr const &ret(Expr const &expr)
        {
            return expr;
        }

        template<typename Expr>
        Expr const &const_parameters(Expr const &expr)
        {
            return expr;
        }

        template<typename Expr>
        Expr const &break_const(Expr const &expr)
        {
            return expr;
        }

        template<typename Lambda>
        proto::unexpr<Lambda> const
        unlambda(Lambda const &lambda)
        {
            return proto::unexpr<Lambda>(lambda);
        }

        template<typename Lambda>
        typename proto::result_of::make_expr<
            tag::protect
          , lldomain
          , Lambda const &
        >::type const
        protect(Lambda const &lambda)
        {
            return proto::make_expr<tag::protect, lldomain>(boost::ref(lambda));
        }

        template<typename T>
        T const std_functor(T const &t)
        {
            return t;
        }

        template<typename T>
        struct ll_static_cast_fun
        {
            typedef T result_type;

            template<typename U>
            T operator()(U &u) const
            {
                return static_cast<T>(u);
            }

            template<typename U>
            T operator()(U const &u) const
            {
                return static_cast<T>(u);
            }
        };

        template<typename T, typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_static_cast_fun<T>
          , U const &
        >::type
        ll_static_cast(U const &u)
        {
            ll_static_cast_fun<T> fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        template<typename T>
        struct ll_const_cast_fun
        {
            typedef T result_type;

            template<typename U>
            T operator()(U &u) const
            {
                return const_cast<T>(u);
            }

            template<typename U>
            T operator()(U const &u) const
            {
                return const_cast<T>(u);
            }
        };

        template<typename T, typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_const_cast_fun<T>
          , U const &
        >::type
        ll_const_cast(U const &u)
        {
            ll_const_cast_fun<T> fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        template<typename T>
        struct ll_dynamic_cast_fun
        {
            typedef T result_type;

            template<typename U>
            T operator()(U &u) const
            {
                return dynamic_cast<T>(u);
            }

            template<typename U>
            T operator()(U const &u) const
            {
                return dynamic_cast<T>(u);
            }
        };

        template<typename T, typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_dynamic_cast_fun<T>
          , U const &
        >::type
        ll_dynamic_cast(U const &u)
        {
            ll_dynamic_cast_fun<T> fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        template<typename T>
        struct ll_reinterpret_cast_fun
        {
            typedef T result_type;

            template<typename U>
            T operator()(U &u) const
            {
                return reinterpret_cast<T>(u);
            }

            template<typename U>
            T operator()(U const &u) const
            {
                return reinterpret_cast<T>(u);
            }
        };

        template<typename T, typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_reinterpret_cast_fun<T>
          , U const &
        >::type
        ll_reinterpret_cast(U const &u)
        {
            ll_reinterpret_cast_fun<T> fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        struct ll_sizeof_fun
        {
            typedef std::size_t result_type;

            template<typename U>
            std::size_t operator()(U const &) const
            {
                return sizeof(U);
            }
        };

        template<typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_sizeof_fun
          , U const &
        >::type
        ll_sizeof(U const &u)
        {
            ll_sizeof_fun fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        struct ll_typeid_fun
        {
            typedef std::type_info const &result_type;

            template<typename U>
            std::type_info const &operator()(U const &) const
            {
                return typeid(U);
            }
        };

        template<typename U>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , ll_typeid_fun
          , U const &
        >::type
        ll_typeid(U const &u)
        {
            ll_typeid_fun fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(u));
        }

        template<typename T>
        struct constructor
        {
            typedef T result_type;

            T operator()() const
            {
                return T();
            }

            #define M0(Z, N, DATA)                                                                  \
            template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>                                      \
            T operator()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) const                    \
            {                                                                                       \
                return T(BOOST_PP_ENUM_PARAMS_Z(Z, N, a));                                          \
            }                                                                                       \
            /**/
            BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0, ~)
            #undef M0
        };

        template<typename T>
        struct new_ptr
        {
            typedef T *result_type;

            T *operator()() const
            {
                return new T();
            }

            #define M0(Z, N, DATA)                                                                  \
            template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>                                      \
            T *operator()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) const                   \
            {                                                                                       \
                return new T(BOOST_PP_ENUM_PARAMS_Z(Z, N, a));                                      \
            }                                                                                       \
            /**/
            BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, M0, ~)
            #undef M0
        };

        struct destructor
        {
            typedef void result_type;

            template<typename T>
            void operator()(T const &t) const
            {
                t.~T();
            }

            template<typename T>
            void operator()(T *const &t) const
            {
                (*t).~T();
            }
        };

        struct delete_ptr
        {
            typedef void result_type;
            template<typename T>
            void operator()(T *t) const
            {
                delete t;
            }
        };

        template<typename T>
        struct new_array
        {
            typedef T *result_type;
            T *operator()(std::size_t n) const
            {
                return new T[n];
            }
        };

        struct delete_array
        {
            typedef void result_type;
            template<typename T>
            void operator()(T *t) const
            {
                delete[] t;
            }
        };

        template<typename T>
        struct type2type {};

        struct try_catch_nil {};

        template<typename Head, typename Tail>
        struct try_catch_cons : Tail
        {
            typedef typename Head::proto_tag::exception_type exception_type;

            try_catch_cons(Head const &head, Tail const &tail)
              : Tail(tail)
              , head(head)
            {}

            template<typename State, typename Data>
            typename result_of<Tail const(State const &, Data &)>::type
            operator()(State const &state, Data &data) const
            {
                return this->invoke(state, data, type2type<exception_type>());
            }

        private:
            // catch(Exception const &)
            template<typename State, typename Data, typename Exception>
            typename result_of<Tail const(State const &, Data &)>::type
            invoke(State const &state, Data &data, type2type<Exception>) const
            {
                typedef typename result_of<Tail const(State const &, Data &)>::type result_type;
                try
                {
                    return static_cast<result_type>(this->Tail::operator()(state, data));
                }
                catch(Exception const &e)
                {
                    return static_cast<result_type>(Eval()(this->head, e, data));
                }
            }

            // catch(...)
            template<typename State, typename Data>
            typename result_of<Tail const(State const &, Data &)>::type
            invoke(State const &state, Data &data, type2type<tag::catch_all_>) const
            {
                typedef typename result_of<Tail const(State const &, Data &)>::type result_type;
                try
                {
                    return static_cast<result_type>(this->Tail::operator()(state, data));
                }
                catch(...)
                {
                    return static_cast<result_type>(Eval()(this->head, tag::catch_all_(), data));
                }
            }

            Head const &head;
        };

        template<typename Head>
        struct try_catch_cons<Head, try_catch_nil> : proto::callable
        {
            try_catch_cons(Head const &head, try_catch_nil const &)
              : head(head)
            {}

            template<typename Sig>
            struct result;

            template<typename This, typename State, typename Data>
            struct result<This(State, Data)>
              : result_of<Eval(Head const &, State, Data)>
            {};

            template<typename State, typename Data>
            typename result_of<Eval(Head const &, State, Data)>::type
            operator()(State const &state, Data &data) const
            {
                return Eval()(this->head, state, data);
            }

        private:
            Head const &head;
        };

        struct try_catch_fun : proto::callable
        {
            template<typename Sig>
            struct result;

            template<typename This, typename Fun, typename State, typename Data>
            struct result<This(Fun, State, Data)>
              : result_of<Fun(State, Data)>
            {};

            template<typename Fun, typename State, typename Data>
            typename result_of<Fun(State const &, Data &)>::type
            operator()(Fun const &fun, State const &state, Data &data) const
            {
                return fun(state, data);
            }
        };

        template<>
        struct Cases::case_<tag::try_>
          : proto::otherwise<
                try_catch_fun(
                    proto::fold<
                        proto::_
                      , try_catch_nil()
                      , try_catch_cons<proto::_, proto::_state>(proto::_, proto::_state)
                    >
                  , proto::_state
                  , proto::_data
                )
            >
        {};

        template<typename E, typename Expr>
        typename proto::result_of::make_expr<tag::catch_<E>, lldomain, Expr const &>::type const
        catch_exception(Expr const &expr)
        {
            return proto::make_expr<tag::catch_<E>, lldomain>(boost::ref(expr));
        }

        template<typename E>
        typename proto::result_of::make_expr<tag::catch_<E>, lldomain, noop_type const &>::type const
        catch_exception()
        {
            return proto::make_expr<tag::catch_<E>, lldomain>(boost::ref(noop));
        }

        template<typename Expr>
        typename proto::result_of::make_expr<
            tag::catch_all_
          , lldomain
          , Expr const &
        >::type const
        catch_all(Expr const &expr)
        {
            return proto::make_expr<tag::catch_all_, lldomain>(boost::ref(expr));
        }

        inline
        proto::result_of::make_expr<tag::catch_all_, lldomain, noop_type const &>::type const
        catch_all()
        {
            return proto::make_expr<tag::catch_all_, lldomain>(boost::ref(noop));
        }

        #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a)                                \
        template<typename_A(N)>                                                                     \
        typename proto::result_of::make_expr<                                                       \
            tag::try_                                                                               \
          , lldomain                                                                                \
          , A_const_ref(N)                                                                          \
        >::type const                                                                               \
        try_catch(A_const_ref_a(N))                                                                 \
        {                                                                                           \
            return proto::make_expr<tag::try_, lldomain>(ref_a(N));                                 \
        }                                                                                           \
        /**/
        BOOST_PROTO_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
        #undef M1

        template<typename Expr>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , throw_fun
          , Expr const &
        >::type const
        throw_exception(Expr const &expr)
        {
            throw_fun fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(expr));
        }

        inline
        proto::result_of::make_expr<proto::tag::function, lldomain, rethrow_fun>::type const
        rethrow()
        {
            return proto::make_expr<proto::tag::function, lldomain>(rethrow_fun());
        }

        struct make_void_fun
        {
            typedef void result_type;
            template<typename T>
            void operator()(T const &) const
            {}
        };

        template<typename Expr>
        typename proto::result_of::make_expr<
            proto::tag::function
          , lldomain
          , make_void_fun
          , Expr const &
        >::type const
        make_void(Expr const &expr)
        {
            make_void_fun fun;
            return proto::make_expr<proto::tag::function, lldomain>(fun, boost::ref(expr));
        }

        #define M1(N, typename_A, A_const_ref, A_const_ref_a, ref_a)                                \
        template<typename_A(N)>                                                                     \
        typename proto::result_of::make_expr<                                                       \
            tag::switch_                                                                            \
          , lldomain                                                                                \
          , A_const_ref(N)                                                                          \
        >::type const                                                                               \
        switch_statement(A_const_ref_a(N))                                                          \
        {                                                                                           \
            return proto::make_expr<tag::switch_, lldomain>(ref_a(N));                              \
        }                                                                                           \
        /**/
        BOOST_PROTO_REPEAT_FROM_TO(2, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M1)
        #undef M1

        template<int I, typename Expr>
        typename proto::result_of::make_expr<tag::case_<I>, lldomain, Expr const &>::type const
        case_statement(Expr const &expr)
        {
            return proto::make_expr<tag::case_<I>, lldomain>(boost::ref(expr));
        }

        template<int I>
        typename proto::result_of::make_expr<tag::case_<I>, lldomain, noop_type const &>::type const
        case_statement()
        {
            return proto::make_expr<tag::case_<I>, lldomain>(boost::ref(noop));
        }

        template<typename Expr>
        typename proto::result_of::make_expr<tag::default_, lldomain, Expr const &>::type const
        default_statement(Expr const &expr)
        {
            return proto::make_expr<tag::default_, lldomain>(boost::ref(expr));
        }

        inline
        proto::result_of::make_expr<tag::default_, lldomain, noop_type const &>::type const
        default_statement()
        {
            return proto::make_expr<tag::default_, lldomain>(boost::ref(noop));
        }

        namespace ll
        {
            struct for_each
            {
                template<typename Sig>
                struct result;

                template<typename This, typename Begin, typename End, typename Fun>
                struct result<This(Begin, End, Fun)>
                  : remove_const<typename remove_reference<Fun>::type>
                {};

                template<typename InIter, typename Fun>
                Fun operator()(InIter begin, InIter end, Fun fun) const
                {
                    return std::for_each(begin, end, fun);
                }
            };
        }

    }}
    
    namespace boost
    {
        template<typename Expr>
        struct result_of<lambda::llexpr<Expr>()>
          : lambda::llexpr<Expr>::template result<lambda::llexpr<Expr>()>
        {};

        template<typename Expr>
        struct result_of<lambda::llexpr<Expr> const()>
          : lambda::llexpr<Expr>::template result<lambda::llexpr<Expr> const()>
        {};
    }

    #ifdef _MSC_VER
    # pragma warning(pop)
    #endif

    #endif

#else

    BOOST_PP_SEQ_FOR_EACH_PRODUCT(
        M2,
        BOOST_PP_REPEAT(BOOST_PP_ITERATION(), M1, ~)
    )

#endif