Initial commit

externals/vcpkg/packages/boost-proto_x64-windows/BUILD_INFO

@@ -0,0 +1,2 @@
+CRTLinkage: dynamic
+LibraryLinkage: dynamic

externals/vcpkg/packages/boost-proto_x64-windows/CONTROL

@@ -0,0 +1,8 @@
+Package: boost-proto
+Version: 1.79.0
+Depends: boost-config, boost-core, boost-fusion, boost-mpl, boost-preprocessor, boost-range, boost-static-assert, boost-type-traits, boost-typeof, boost-utility, boost-vcpkg-helpers
+Architecture: x64-windows
+Multi-Arch: same
+Abi: cd73fa3d717fc87fbbf3196e97df3c6fbb413a5b9f36518da6513e084f41781f
+Description: Boost proto module
+Type: Port

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/args.hpp

@@ -0,0 +1,132 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file args.hpp
+/// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
+/// class templates.
+//
+//  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)
+
+#ifndef BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
+#define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/detail/is_noncopyable.hpp>
+
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        /// INTERNAL ONLY
+        template<typename Expr>
+        struct expr_traits
+        {
+            typedef Expr value_type;
+            typedef Expr &reference;
+            typedef Expr const &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename Expr>
+        struct expr_traits<Expr &>
+        {
+            typedef Expr value_type;
+            typedef Expr &reference;
+            typedef Expr &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename Expr>
+        struct expr_traits<Expr const &>
+        {
+            typedef Expr value_type;
+            typedef Expr const &reference;
+            typedef Expr const &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename T>
+        struct term_traits
+        {
+            typedef T value_type;
+            typedef T &reference;
+            typedef T const &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename T>
+        struct term_traits<T &>
+        {
+            typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type value_type;
+            typedef T &reference;
+            typedef T &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename T>
+        struct term_traits<T const &>
+        {
+            typedef T value_type;
+            typedef T const &reference;
+            typedef T const &const_reference;
+        };
+
+        /// INTERNAL ONLY
+        template<typename T, std::size_t N>
+        struct term_traits<T (&)[N]>
+        {
+            typedef T value_type[N];
+            typedef T (&reference)[N];
+            typedef T (&const_reference)[N];
+        };
+
+        /// INTERNAL ONLY
+        template<typename T, std::size_t N>
+        struct term_traits<T const (&)[N]>
+        {
+            typedef T value_type[N];
+            typedef T const (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+
+        /// INTERNAL ONLY
+        template<typename T, std::size_t N>
+        struct term_traits<T[N]>
+        {
+            typedef T value_type[N];
+            typedef T (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+
+        /// INTERNAL ONLY
+        template<typename T, std::size_t N>
+        struct term_traits<T const[N]>
+        {
+            typedef T value_type[N];
+            typedef T const (&reference)[N];
+            typedef T const (&const_reference)[N];
+        };
+    }
+
+    namespace argsns_
+    {
+        // This is where term and all the different listN templates are defined
+        #include <boost/proto/detail/args.hpp>
+    }
+
+}}
+
+#endif
+

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/context.hpp

@@ -0,0 +1,16 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file context.hpp
+/// Includes all the context classes in the context/ sub-directory.
+//
+//  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)
+
+#ifndef BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
+#define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
+
+#include <boost/proto/context/null.hpp>
+#include <boost/proto/context/default.hpp>
+#include <boost/proto/context/callable.hpp>
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/context/callable.hpp

@@ -0,0 +1,229 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file callable.hpp
+/// Definintion of callable_context\<\>, an evaluation context for
+/// proto::eval() that explodes each node and calls the derived context
+/// type with the expressions constituents. If the derived context doesn't
+/// have an overload that handles this node, fall back to some other
+/// context.
+//
+//  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)
+
+#ifndef BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
+#define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/selection/max.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp> // for child_c
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Context>
+        struct callable_context_wrapper
+          : remove_cv<Context>::type
+        {
+            callable_context_wrapper();
+            typedef private_type_ fun_type(...);
+            operator fun_type *() const;
+
+            BOOST_DELETED_FUNCTION(callable_context_wrapper &operator =(callable_context_wrapper const &))
+        };
+
+        template<typename T>
+        yes_type check_is_expr_handled(T const &);
+
+        no_type check_is_expr_handled(private_type_ const &);
+
+        template<typename Expr, typename Context, long Arity = Expr::proto_arity_c>
+        struct is_expr_handled;
+
+        template<typename Expr, typename Context>
+        struct is_expr_handled<Expr, Context, 0>
+        {
+            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::value(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
+          , long Arity          // = Expr::proto_arity_c
+        >
+        struct callable_eval
+        {};
+
+        /// \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(), value(expr))
+        /// \endcode
+        template<typename Expr, typename Context>
+        struct callable_eval<Expr, Context, 0>
+        {
+            typedef typename proto::result_of::value<Expr const &>::type value_type;
+
+            typedef
+                typename BOOST_PROTO_RESULT_OF<
+                    Context(typename Expr::proto_tag, value_type)
+                >::type
+            result_type;
+
+            /// \param expr The current expression
+            /// \param context The callable evaluation context
+            /// \return <tt>context(Expr::proto_tag(), value(expr))</tt>
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return context(typename Expr::proto_tag(), proto::value(expr));
+            }
+        };
+
+        /// \brief An evaluation context adaptor that makes authoring a
+        /// context a simple matter of writing function overloads, rather
+        /// then writing template specializations.
+        ///
+        /// <tt>callable_context\<\></tt> is a base class that implements
+        /// the context protocol by passing fanned-out expression nodes to
+        /// the derived context, making it easy to customize the handling
+        /// of expression types by writing function overloads. Only those
+        /// expression types needing special handling require explicit
+        /// handling. All others are dispatched to a user-specified
+        /// default context, \c DefaultCtx.
+        ///
+        /// <tt>callable_context\<\></tt> is defined simply as:
+        ///
+        /// \code
+        /// template<typename Context, typename DefaultCtx = default_context>
+        /// struct callable_context
+        /// {
+        ///    template<typename Expr, typename ThisContext = Context>
+        ///     struct eval
+        ///       : mpl::if_<
+        ///             is_expr_handled_<Expr, Context> // For exposition
+        ///           , callable_eval<Expr, ThisContext>
+        ///           , typename DefaultCtx::template eval<Expr, Context>
+        ///         >::type
+        ///     {};
+        /// };
+        /// \endcode
+        ///
+        /// The Boolean metafunction <tt>is_expr_handled_\<\></tt> uses
+        /// metaprogramming tricks to determine whether \c Context has
+        /// an overloaded function call operator that accepts the
+        /// fanned-out constituents of an expression of type \c Expr.
+        /// If so, the handling of the expression is dispatched to
+        /// <tt>callable_eval\<\></tt>. If not, it is dispatched to
+        /// the user-specified \c DefaultCtx.
+        ///
+        /// Below is an example of how to use <tt>callable_context\<\></tt>:
+        ///
+        /// \code
+        /// // An evaluation context that increments all
+        /// // integer terminals in-place.
+        /// struct increment_ints
+        ///  : callable_context<
+        ///         increment_ints const    // derived context
+        ///       , null_context const      // fall-back context
+        ///     >
+        /// {
+        ///     typedef void result_type;
+        ///
+        ///     // Handle int terminals here:
+        ///     void operator()(proto::tag::terminal, int &i) const
+        ///     {
+        ///        ++i;
+        ///     }
+        /// };
+        /// \endcode
+        ///
+        /// With \c increment_ints, we can do the following:
+        ///
+        /// \code
+        /// literal<int> i = 0, j = 10;
+        /// proto::eval( i - j * 3.14, increment_ints() );
+        ///
+        /// assert( i.get() == 1 && j.get() == 11 );
+        /// \endcode
+        template<
+            typename Context
+          , typename DefaultCtx // = default_context
+        >
+        struct callable_context
+        {
+            /// A BinaryFunction that accepts an \c Expr and a
+            /// \c Context, and either fans out the expression and passes
+            /// it to the context, or else hands off the expression to
+            /// \c DefaultCtx.
+            ///
+            /// If \c Context is a PolymorphicFunctionObject such that
+            /// it can be invoked with the tag and children of \c Expr,
+            /// as <tt>ctx(Expr::proto_tag(), child_c\<0\>(expr), child_c\<1\>(expr)...)</tt>,
+            /// then <tt>eval\<Expr, ThisContext\></tt> inherits from
+            /// <tt>callable_eval\<Expr, ThisContext\></tt>. Otherwise,
+            /// <tt>eval\<Expr, ThisContext\></tt> inherits from
+            /// <tt>DefaultCtx::eval\<Expr, Context\></tt>.
+            template<typename Expr, typename ThisContext = Context>
+            struct eval
+              : mpl::if_c<
+                    detail::is_expr_handled<Expr, Context>::value
+                  , callable_eval<Expr, ThisContext>
+                  , typename DefaultCtx::template eval<Expr, Context>
+                >::type
+            {};
+        };
+    }
+
+    #include <boost/proto/context/detail/callable_eval.hpp>
+
+}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/context/default.hpp

@@ -0,0 +1,409 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file default.hpp
+/// Definintion of default_context, a default evaluation context for
+/// proto::eval() that uses Boost.Typeof to deduce return types
+/// of the built-in operators.
+//
+//  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)
+
+#ifndef BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
+#define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_shifted.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_member_pointer.hpp>
+#include <boost/type_traits/is_member_object_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/tags.hpp>
+#include <boost/proto/eval.hpp>
+#include <boost/proto/traits.hpp> // for proto::child_c()
+#include <boost/proto/detail/decltype.hpp>
+
+namespace boost { namespace proto
+{
+/// INTERNAL ONLY
+///
+#define UNREF(x) typename boost::remove_reference<x>::type
+
+    namespace context
+    {
+        template<
+            typename Expr
+          , typename Context
+          , typename Tag        // = typename Expr::proto_tag
+          , long Arity          // = Expr::proto_arity_c
+        >
+        struct default_eval
+        {};
+
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, tag::terminal, 0>
+        {
+            typedef
+                typename proto::result_of::value<Expr &>::type
+            result_type;
+
+            result_type operator ()(Expr &expr, Context &) const
+            {
+                return proto::value(expr);
+            }
+        };
+
+        /// INTERNAL ONLY
+        ///
+    #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE)                                       \
+        template<typename Expr, typename Context>                                               \
+        struct default_eval<Expr, Context, TAG, 1>                                              \
+        {                                                                                       \
+        private:                                                                                \
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;                       \
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;               \
+        public:                                                                                 \
+            BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type)                    \
+            result_type operator ()(Expr &expr, Context &ctx) const                             \
+            {                                                                                   \
+                return OP proto::eval(proto::child_c<0>(expr), ctx);                            \
+            }                                                                                   \
+        };                                                                                      \
+        /**/
+
+        /// INTERNAL ONLY
+        ///
+    #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE)                              \
+        template<typename Expr, typename Context>                                               \
+        struct default_eval<Expr, Context, TAG, 2>                                              \
+        {                                                                                       \
+        private:                                                                                \
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;                       \
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;                       \
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;               \
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;               \
+        public:                                                                                 \
+            BOOST_PROTO_DECLTYPE_(                                                              \
+                proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>()                        \
+              , result_type                                                                     \
+            )                                                                                   \
+            result_type operator ()(Expr &expr, Context &ctx) const                             \
+            {                                                                                   \
+                return proto::eval(                                                             \
+                    proto::child_c<0>(expr), ctx) OP proto::eval(proto::child_c<1>(expr)        \
+                  , ctx                                                                         \
+                );                                                                              \
+            }                                                                                   \
+        };                                                                                      \
+        /**/
+
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(+, proto::tag::unary_plus, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(-, proto::tag::negate, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(*, proto::tag::dereference, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(~, proto::tag::complement, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(&, proto::tag::address_of, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(!, proto::tag::logical_not, make)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(++, proto::tag::pre_inc, make_mutable)
+        BOOST_PROTO_UNARY_DEFAULT_EVAL(--, proto::tag::pre_dec, make_mutable)
+
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, proto::tag::shift_left, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, proto::tag::shift_right, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(*, proto::tag::multiplies, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(/, proto::tag::divides, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(%, proto::tag::modulus, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(+, proto::tag::plus, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(-, proto::tag::minus, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(<, proto::tag::less, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(>, proto::tag::greater, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, proto::tag::less_equal, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, proto::tag::greater_equal, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(==, proto::tag::equal_to, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, proto::tag::not_equal_to, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(||, proto::tag::logical_or, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, proto::tag::logical_and, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(&, proto::tag::bitwise_and, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(|, proto::tag::bitwise_or, make, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(^, proto::tag::bitwise_xor, make, make)
+
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(=, proto::tag::assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, proto::tag::shift_left_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, proto::tag::shift_right_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, proto::tag::multiplies_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, proto::tag::divides_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, proto::tag::modulus_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, proto::tag::plus_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, proto::tag::minus_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, proto::tag::bitwise_and_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, proto::tag::bitwise_or_assign, make_mutable, make)
+        BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, proto::tag::bitwise_xor_assign, make_mutable, make)
+
+    #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
+    #undef BOOST_PROTO_BINARY_DEFAULT_EVAL
+
+        /// INTERNAL ONLY
+        template<typename Expr, typename Context>
+        struct is_member_function_eval
+          : is_member_function_pointer<
+                typename detail::uncvref<
+                    typename proto::result_of::eval<
+                        typename remove_reference<
+                            typename proto::result_of::child_c<Expr, 1>::type
+                        >::type
+                      , Context
+                    >::type
+                >::type
+            >
+        {};
+
+        /// INTERNAL ONLY
+        template<typename Expr, typename Context, bool IsMemFunCall>
+        struct memfun_eval
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
+        public:
+            typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return detail::mem_ptr_fun<r0, r1>()(
+                    proto::eval(proto::child_c<0>(expr), ctx)
+                  , proto::eval(proto::child_c<1>(expr), ctx)
+                );
+            }
+        };
+
+        /// INTERNAL ONLY
+        template<typename Expr, typename Context>
+        struct memfun_eval<Expr, Context, true>
+        {
+        private:
+            typedef typename result_of::child_c<Expr, 0>::type e0;
+            typedef typename result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
+        public:
+            typedef detail::memfun<r0, r1> result_type;
+            result_type const operator ()(Expr &expr, Context &ctx) const
+            {
+                return detail::memfun<r0, r1>(
+                    proto::eval(proto::child_c<0>(expr), ctx)
+                  , proto::eval(proto::child_c<1>(expr), ctx)
+                );
+            }
+        };
+
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, tag::mem_ptr, 2>
+          : memfun_eval<Expr, Context, is_member_function_eval<Expr, Context>::value>
+        {};
+
+        // Handle post-increment specially.
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::post_inc, 1>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+        public:
+            BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx) ++;
+            }
+        };
+
+        // Handle post-decrement specially.
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::post_dec, 1>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+        public:
+            BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx) --;
+            }
+        };
+
+        // Handle subscript specially.
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::subscript, 2>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
+        public:
+            BOOST_PROTO_DECLTYPE_(proto::detail::make_subscriptable<r0>()[proto::detail::make<r1>()], result_type)
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx)[proto::eval(proto::child_c<1>(expr), ctx)];
+            }
+        };
+
+        // Handle if_else_ specially.
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::if_else_, 3>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::child_c<Expr, 2>::type e2;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
+            typedef typename proto::result_of::eval<UNREF(e2), Context>::type r2;
+        public:
+            BOOST_PROTO_DECLTYPE_(
+                proto::detail::make<r0>()
+              ? proto::detail::make<r1>()
+              : proto::detail::make<r2>()
+              , result_type
+            )
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx)
+                      ? proto::eval(proto::child_c<1>(expr), ctx)
+                      : proto::eval(proto::child_c<2>(expr), ctx);
+            }
+        };
+
+        // Handle comma specially.
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::comma, 2>
+        {
+        private:
+            typedef typename proto::result_of::child_c<Expr, 0>::type e0;
+            typedef typename proto::result_of::child_c<Expr, 1>::type e1;
+            typedef typename proto::result_of::eval<UNREF(e0), Context>::type r0;
+            typedef typename proto::result_of::eval<UNREF(e1), Context>::type r1;
+        public:
+            typedef typename proto::detail::comma_result<r0, r1>::type result_type;
+            result_type operator ()(Expr &expr, Context &ctx) const
+            {
+                return proto::eval(proto::child_c<0>(expr), ctx), proto::eval(proto::child_c<1>(expr), ctx);
+            }
+        };
+
+        // Handle function specially
+        #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA)                                       \
+            typename proto::result_of::eval<                                                    \
+                typename remove_reference<                                                      \
+                    typename proto::result_of::child_c<DATA, N>::type                           \
+                >::type                                                                         \
+              , Context                                                                         \
+            >::type                                                                             \
+            /**/
+
+        #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA)                                            \
+            proto::eval(proto::child_c<N>(DATA), context)                                       \
+            /**/
+
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::function, 1>
+        {
+            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()>::type
+            result_type;
+
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)();
+            }
+        };
+
+        template<typename Expr, typename Context>
+        struct default_eval<Expr, Context, proto::tag::function, 2>
+        {
+            typedef
+                typename proto::detail::result_of_fixup<
+                    BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
+                >::type
+            function_type;
+
+            typedef
+                typename detail::result_of_<
+                    function_type(BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr))
+                >::type
+            result_type;
+
+            result_type operator ()(Expr &expr, Context &context) const
+            {
+                return this->invoke(
+                    expr
+                  , context
+                  , is_member_function_pointer<function_type>()
+                  , is_member_object_pointer<function_type>()
+                );
+            }
+
+        private:
+            result_type invoke(Expr &expr, Context &context, mpl::false_, mpl::false_) const
+            {
+                return BOOST_PROTO_DEFAULT_EVAL(~, 0, expr)(BOOST_PROTO_DEFAULT_EVAL(~, 1, expr));
+            }
+
+            result_type invoke(Expr &expr, Context &context, mpl::true_, mpl::false_) 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)
+                )();
+            }
+
+            result_type invoke(Expr &expr, Context &context, mpl::false_, 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)
+                );
+            }
+        };
+
+        // Additional specialization are generated by the preprocessor
+        #include <boost/proto/context/detail/default_eval.hpp>
+
+        #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
+        #undef BOOST_PROTO_DEFAULT_EVAL
+
+        /// default_context
+        ///
+        struct default_context
+        {
+            /// default_context::eval
+            ///
+            template<typename Expr, typename ThisContext = default_context const>
+            struct eval
+              : default_eval<Expr, ThisContext>
+            {};
+        };
+
+    } // namespace context
+
+}} // namespace boost::proto
+
+#undef UNREF
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/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

externals/vcpkg/packages/boost-proto_x64-windows/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

externals/vcpkg/packages/boost-proto_x64-windows/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

externals/vcpkg/packages/boost-proto_x64-windows/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)
+                );
+            }
+        };
+    }

externals/vcpkg/packages/boost-proto_x64-windows/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));
+        }
+    };

externals/vcpkg/packages/boost-proto_x64-windows/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);
+        }
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/context/null.hpp

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file null.hpp
+/// Definintion of null_context\<\>, an evaluation context for
+/// proto::eval() that simply evaluates each child expression, doesn't
+/// combine the results at all, and returns void.
+//
+//  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)
+
+#ifndef BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
+#define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
+
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/eval.hpp>
+#include <boost/proto/traits.hpp>
+
+namespace boost { namespace proto { namespace context
+{
+
+    template<
+        typename Expr
+      , typename Context
+      , long Arity          // = Expr::proto_arity_c
+    >
+    struct null_eval
+    {};
+
+    template<typename Expr, typename Context>
+    struct null_eval<Expr, Context, 0>
+    {
+        typedef void result_type;
+        void operator()(Expr &, Context &) const
+        {}
+    };
+
+    // Additional specializations generated by the preprocessor
+    #include <boost/proto/context/detail/null_eval.hpp>
+
+    /// null_context
+    ///
+    struct null_context
+    {
+        /// null_context::eval
+        ///
+        template<typename Expr, typename ThisContext = null_context const>
+        struct eval
+          : null_eval<Expr, ThisContext>
+        {};
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/core.hpp

@@ -0,0 +1,30 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file core.hpp
+/// Includes the core of Proto. Not included are the contexts, transforms and
+/// debugging utilities.
+//
+//  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)
+
+#ifndef BOOST_PROTO_CORE_HPP_EAN_04_01_2005
+#define BOOST_PROTO_CORE_HPP_EAN_04_01_2005
+
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/args.hpp>
+#include <boost/proto/tags.hpp>
+#include <boost/proto/eval.hpp>
+#include <boost/proto/expr.hpp>
+#include <boost/proto/repeat.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/domain.hpp>
+#include <boost/proto/fusion.hpp>
+#include <boost/proto/matches.hpp>
+#include <boost/proto/extends.hpp>
+#include <boost/proto/literal.hpp>
+#include <boost/proto/generate.hpp>
+#include <boost/proto/operators.hpp>
+#include <boost/proto/deep_copy.hpp>
+#include <boost/proto/make_expr.hpp>
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/debug.hpp

@@ -0,0 +1,283 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file debug.hpp
+/// Utilities for debugging Proto expression trees
+//
+//  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)
+
+#ifndef BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
+#define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
+
+#include <iostream>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/core/ref.hpp>
+#include <boost/core/typeinfo.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/matches.hpp>
+#include <boost/proto/fusion.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+
+namespace boost { namespace proto
+{
+    namespace tagns_ { namespace tag
+    {
+    #define BOOST_PROTO_DEFINE_TAG_INSERTION(Tag)                               \
+        /** \brief INTERNAL ONLY */                                             \
+        inline std::ostream &operator <<(std::ostream &sout, Tag const &)       \
+        {                                                                       \
+            return sout << BOOST_PP_STRINGIZE(Tag);                             \
+        }                                                                       \
+        /**/
+
+        BOOST_PROTO_DEFINE_TAG_INSERTION(terminal)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(unary_plus)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(negate)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(dereference)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(complement)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(address_of)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(logical_not)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(pre_inc)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(pre_dec)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(post_inc)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(post_dec)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(divides)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(modulus)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(plus)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(minus)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(less)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(greater)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(less_equal)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(greater_equal)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(equal_to)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(not_equal_to)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(logical_or)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(logical_and)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(comma)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(mem_ptr)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(shift_left_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(shift_right_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(multiplies_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(divides_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(modulus_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(plus_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(minus_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_and_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_or_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(bitwise_xor_assign)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(subscript)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(member)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(if_else_)
+        BOOST_PROTO_DEFINE_TAG_INSERTION(function)
+
+    #undef BOOST_PROTO_DEFINE_TAG_INSERTION
+    }}
+
+    namespace hidden_detail_
+    {
+        struct ostream_wrapper
+        {
+            ostream_wrapper(std::ostream &sout)
+              : sout_(sout)
+            {}
+
+            std::ostream &sout_;
+
+            BOOST_DELETED_FUNCTION(ostream_wrapper &operator =(ostream_wrapper const &))
+        };
+
+        struct named_any
+        {
+            template<typename T>
+            named_any(T const &)
+              : name_(BOOST_CORE_TYPEID(T).name())
+            {}
+
+            char const *name_;
+        };
+
+        inline std::ostream &operator <<(ostream_wrapper sout_wrap, named_any t)
+        {
+            return sout_wrap.sout_ << t.name_;
+        }
+    }
+
+    namespace detail
+    {
+        // copyable functor to pass by value to fusion::foreach
+        struct display_expr_impl;
+        struct display_expr_impl_functor
+        {
+            display_expr_impl_functor(display_expr_impl const& impl): impl_(impl)
+            {}
+
+            template<typename Expr>
+            void operator()(Expr const &expr) const
+            {
+                this->impl_(expr);
+            }
+
+        private:
+            display_expr_impl const& impl_;
+        };
+
+        struct display_expr_impl
+        {
+            explicit display_expr_impl(std::ostream &sout, int depth = 0)
+              : depth_(depth)
+              , first_(true)
+              , sout_(sout)
+            {}
+
+            template<typename Expr>
+            void operator()(Expr const &expr) const
+            {
+                this->impl(expr, mpl::long_<arity_of<Expr>::value>());
+            }
+
+            BOOST_DELETED_FUNCTION(display_expr_impl(display_expr_impl const &))
+            BOOST_DELETED_FUNCTION(display_expr_impl &operator =(display_expr_impl const &))
+        private:
+
+            template<typename Expr>
+            void impl(Expr const &expr, mpl::long_<0>) const
+            {
+                using namespace hidden_detail_;
+                typedef typename tag_of<Expr>::type tag;
+                this->sout_.width(this->depth_);
+                this->sout_ << (this->first_? "" : ", ");
+                this->sout_ << tag() << "(" << proto::value(expr) << ")\n";
+                this->first_ = false;
+            }
+
+            template<typename Expr, typename Arity>
+            void impl(Expr const &expr, Arity) const
+            {
+                using namespace hidden_detail_;
+                typedef typename tag_of<Expr>::type tag;
+                this->sout_.width(this->depth_);
+                this->sout_ << (this->first_? "" : ", ");
+                this->sout_ << tag() << "(\n";
+                display_expr_impl display(this->sout_, this->depth_ + 4);
+                fusion::for_each(expr, display_expr_impl_functor(display));
+                this->sout_.width(this->depth_);
+                this->sout_ << "" << ")\n";
+                this->first_ = false;
+            }
+
+            int depth_;
+            mutable bool first_;
+            std::ostream &sout_;
+        };
+    }
+
+    namespace functional
+    {
+        /// \brief Pretty-print a Proto expression tree.
+        ///
+        /// A PolymorphicFunctionObject which accepts a Proto expression
+        /// tree and pretty-prints it to an \c ostream for debugging
+        /// purposes.
+        struct display_expr
+        {
+            BOOST_PROTO_CALLABLE()
+
+            typedef void result_type;
+
+            /// \param sout  The \c ostream to which the expression tree
+            ///              will be written.
+            /// \param depth The starting indentation depth for this node.
+            ///              Children nodes will be displayed at a starting
+            ///              depth of <tt>depth+4</tt>.
+            explicit display_expr(std::ostream &sout = std::cout, int depth = 0)
+              : depth_(depth)
+              , sout_(sout)
+            {}
+
+            /// \brief Pretty-print the current node in a Proto expression
+            /// tree.
+            template<typename Expr>
+            void operator()(Expr const &expr) const
+            {
+                detail::display_expr_impl(this->sout_, this->depth_)(expr);
+            }
+
+        private:
+            int depth_;
+            reference_wrapper<std::ostream> sout_;
+        };
+    }
+
+    /// \brief Pretty-print a Proto expression tree.
+    ///
+    /// \note Equivalent to <tt>functional::display_expr(0, sout)(expr)</tt>
+    /// \param expr The Proto expression tree to pretty-print
+    /// \param sout The \c ostream to which the output should be
+    ///             written. If not specified, defaults to
+    ///             <tt>std::cout</tt>.
+    template<typename Expr>
+    void display_expr(Expr const &expr, std::ostream &sout)
+    {
+        functional::display_expr(sout, 0)(expr);
+    }
+
+    /// \overload
+    ///
+    template<typename Expr>
+    void display_expr(Expr const &expr)
+    {
+        functional::display_expr()(expr);
+    }
+
+    /// \brief Assert at compile time that a particular expression
+    ///        matches the specified grammar.
+    ///
+    /// \note Equivalent to <tt>BOOST_MPL_ASSERT((proto::matches\<Expr, Grammar\>))</tt>
+    /// \param expr The Proto expression to check againts <tt>Grammar</tt>
+    template<typename Grammar, typename Expr>
+    void assert_matches(Expr const & /*expr*/)
+    {
+        BOOST_MPL_ASSERT((proto::matches<Expr, Grammar>));
+    }
+
+    /// \brief Assert at compile time that a particular expression
+    ///        does not match the specified grammar.
+    ///
+    /// \note Equivalent to <tt>BOOST_MPL_ASSERT_NOT((proto::matches\<Expr, Grammar\>))</tt>
+    /// \param expr The Proto expression to check againts <tt>Grammar</tt>
+    template<typename Grammar, typename Expr>
+    void assert_matches_not(Expr const & /*expr*/)
+    {
+        BOOST_MPL_ASSERT_NOT((proto::matches<Expr, Grammar>));
+    }
+
+    /// \brief Assert at compile time that a particular expression
+    ///        matches the specified grammar.
+    ///
+    /// \note Equivalent to <tt>proto::assert_matches\<Grammar\>(Expr)</tt>
+    /// \param Expr The Proto expression to check againts <tt>Grammar</tt>
+    /// \param Grammar The grammar used to validate Expr.
+    #define BOOST_PROTO_ASSERT_MATCHES(Expr, Grammar)                                               \
+        (true ? (void)0 : boost::proto::assert_matches<Grammar>(Expr))
+
+    /// \brief Assert at compile time that a particular expression
+    ///        does not match the specified grammar.
+    ///
+    /// \note Equivalent to <tt>proto::assert_matches_not\<Grammar\>(Expr)</tt>
+    /// \param Expr The Proto expression to check againts <tt>Grammar</tt>
+    /// \param Grammar The grammar used to validate Expr.
+    #define BOOST_PROTO_ASSERT_MATCHES_NOT(Expr, Grammar)                                           \
+        (true ? (void)0 : boost::proto::assert_matches_not<Grammar>(Expr))
+
+}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/deep_copy.hpp

@@ -0,0 +1,163 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file deep_copy.hpp
+/// Replace all nodes stored by reference by nodes stored by value.
+//
+//  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)
+
+#ifndef BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
+#define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/args.hpp>
+#include <boost/proto/expr.hpp>
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename Expr, long Arity = Expr::proto_arity_c>
+        struct deep_copy_impl;
+
+        template<typename Expr>
+        struct deep_copy_impl<Expr, 0>
+        {
+            typedef
+                typename base_expr<
+                    typename Expr::proto_domain
+                  , tag::terminal
+                  , term<typename term_traits<typename Expr::proto_child0>::value_type>
+                >::type
+            expr_type;
+
+            typedef typename Expr::proto_generator proto_generator;
+            typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+
+            template<typename Expr2, typename S, typename D>
+            result_type operator()(Expr2 const &e, S const &, D const &) const
+            {
+                return proto_generator()(expr_type::make(e.proto_base().child0));
+            }
+        };
+    }
+
+    namespace result_of
+    {
+        /// \brief A metafunction for calculating the return type
+        /// of \c proto::deep_copy().
+        ///
+        /// A metafunction for calculating the return type
+        /// of \c proto::deep_copy(). The type parameter \c Expr
+        /// should be the type of a Proto expression tree.
+        /// It should not be a reference type, nor should it
+        /// be cv-qualified.
+        template<typename Expr>
+        struct deep_copy
+        {
+            typedef
+                typename detail::deep_copy_impl<
+                    BOOST_PROTO_UNCVREF(Expr)
+                >::result_type
+            type;
+        };
+    }
+
+    namespace functional
+    {
+        /// \brief A PolymorphicFunctionObject type for deep-copying
+        /// Proto expression trees.
+        ///
+        /// A PolymorphicFunctionObject type for deep-copying
+        /// Proto expression trees. When a tree is deep-copied,
+        /// all internal nodes and most terminals held by reference
+        /// are instead held by value.
+        ///
+        /// \attention Terminals of reference-to-function type are
+        /// left unchanged. Terminals of reference-to-array type are
+        /// stored by value, which can cause a large amount of data
+        /// to be passed by value and stored on the stack.
+        struct deep_copy
+        {
+            BOOST_PROTO_CALLABLE()
+
+            template<typename Sig>
+            struct result;
+
+            template<typename This, typename Expr>
+            struct result<This(Expr)>
+            {
+                typedef
+                    typename detail::deep_copy_impl<
+                        BOOST_PROTO_UNCVREF(Expr)
+                    >::result_type
+                type;
+            };
+
+            /// \brief Deep-copies a Proto expression tree, turning all
+            /// nodes and terminals held by reference into ones held by
+            /// value.
+            template<typename Expr>
+            typename result_of::deep_copy<Expr>::type
+            operator()(Expr const &e) const
+            {
+                return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
+            }
+        };
+    }
+
+    /// \brief A function for deep-copying
+    /// Proto expression trees.
+    ///
+    /// A function for deep-copying
+    /// Proto expression trees. When a tree is deep-copied,
+    /// all internal nodes and most terminals held by reference
+    /// are instead held by value.
+    ///
+    /// \attention Terminals of reference-to-function type are
+    /// left unchanged.
+    ///
+    /// \sa proto::functional::deep_copy.
+    template<typename Expr>
+    typename proto::result_of::deep_copy<Expr>::type
+    deep_copy(Expr const &e)
+    {
+        return proto::detail::deep_copy_impl<Expr>()(e, 0, 0);
+    }
+
+    /// \brief A PrimitiveTransform for deep-copying
+    /// Proto expression trees.
+    ///
+    /// A PrimitiveTransform for deep-copying
+    /// Proto expression trees. When a tree is deep-copied,
+    /// all internal nodes and most terminals held by reference
+    /// are instead held by value.
+    ///
+    /// \attention Terminals of reference-to-function type are
+    /// left unchanged.
+    ///
+    /// \sa proto::functional::deep_copy.
+    struct _deep_copy
+      : proto::transform<_deep_copy>
+    {
+        template<typename E, typename S, typename D>
+        struct impl
+          : detail::deep_copy_impl<BOOST_PROTO_UNCVREF(E)>
+        {};
+    };
+
+    namespace detail
+    {
+        // include the definition of deep_copy_impl
+        #include <boost/proto/detail/deep_copy.hpp>
+    }
+
+}}
+
+#endif // BOOST_PROTO_COMPILER_DEEP_COPY_HPP_EAN_11_21_2006
+

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/and_n.hpp

@@ -0,0 +1,94 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/and_n.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/and_n.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file and_n.hpp
+    /// Definitions of and_N, and_impl
+    //
+    //  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, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/and_n.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    // Assymetry here between the handling of and_N and or_N because
+    // and_N is used by lambda_matches up to BOOST_PROTO_MAX_ARITY,
+    // regardless of how low BOOST_PROTO_MAX_LOGICAL_ARITY is.
+    template<bool B, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
+    struct BOOST_PP_CAT(and_, N)
+    #if 2 == N
+      : mpl::bool_<P0::value>
+    {};
+    #else
+      : BOOST_PP_CAT(and_, BOOST_PP_DEC(N))<
+            P0::value BOOST_PP_COMMA_IF(BOOST_PP_SUB(N,2))
+            BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_PP_DEC(N), P)
+        >
+    {};
+    #endif
+
+    template<BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), typename P)>
+    struct BOOST_PP_CAT(and_, N)<false, BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(N), P)>
+      : mpl::false_
+    {};
+
+    #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY
+
+        template<BOOST_PP_ENUM_PARAMS(N, typename G), typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<BOOST_PP_ENUM_PARAMS(N, G)>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            #define M0(Z, N, DATA)                                                            \
+            typedef                                                                           \
+                typename proto::when<proto::_, BOOST_PP_CAT(G, N)>                            \
+                    ::template impl<Expr, State, Data>                                        \
+            BOOST_PP_CAT(Gimpl, N);                                                           \
+            /**/
+            BOOST_PP_REPEAT(N, M0, ~)
+            #undef M0
+
+            typedef typename BOOST_PP_CAT(Gimpl, BOOST_PP_DEC(N))::result_type result_type;
+
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                // Fix: jfalcou - 12/29/2010
+                // Avoid the use of comma operator here so as not to find Proto's
+                // by accident.
+                // expands to G0()(e,s,d); G1()(e,s,d); ... G{N-1}()(e,s,d);
+                #define M0(Z,N,DATA) BOOST_PP_CAT(Gimpl,N)()(e,s,d);
+                BOOST_PP_REPEAT(BOOST_PP_DEC(N),M0,~)
+                return BOOST_PP_CAT(Gimpl,BOOST_PP_DEC(N))()(e,s,d);
+                #undef M0
+            }
+        };
+
+    #endif
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/any.hpp

@@ -0,0 +1,84 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file any.hpp
+/// Contains definition the detail::any type
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_DETAIL_ANY_HPP_EAN_18_07_2012
+#define BOOST_PROTO_DETAIL_ANY_HPP_EAN_18_07_2012
+
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        namespace anyns
+        {
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            struct any
+            {
+                template<typename T> any(T const &) {}
+                any operator[](any);
+                #define M0(Z, N, DATA) any operator()(BOOST_PP_ENUM_PARAMS_Z(Z, N, any BOOST_PP_INTERCEPT));
+                BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, M0, ~)
+                #undef M0
+
+                template<typename T>
+                operator T &() const volatile;
+
+                any operator+();
+                any operator-();
+                any operator*();
+                any operator&();
+                any operator~();
+                any operator!();
+                any operator++();
+                any operator--();
+                any operator++(int);
+                any operator--(int);
+
+                friend any operator<<(any, any);
+                friend any operator>>(any, any);
+                friend any operator*(any, any);
+                friend any operator/(any, any);
+                friend any operator%(any, any);
+                friend any operator+(any, any);
+                friend any operator-(any, any);
+                friend any operator<(any, any);
+                friend any operator>(any, any);
+                friend any operator<=(any, any);
+                friend any operator>=(any, any);
+                friend any operator==(any, any);
+                friend any operator!=(any, any);
+                friend any operator||(any, any);
+                friend any operator&&(any, any);
+                friend any operator&(any, any);
+                friend any operator|(any, any);
+                friend any operator^(any, any);
+                friend any operator,(any, any);
+                friend any operator->*(any, any);
+
+                friend any operator<<=(any, any);
+                friend any operator>>=(any, any);
+                friend any operator*=(any, any);
+                friend any operator/=(any, any);
+                friend any operator%=(any, any);
+                friend any operator+=(any, any);
+                friend any operator-=(any, any);
+                friend any operator&=(any, any);
+                friend any operator|=(any, any);
+                friend any operator^=(any, any);
+            };
+        }
+
+        using anyns::any;
+    }
+}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/args.hpp

@@ -0,0 +1,85 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/args.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA)                                              \
+        typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N);                                    \
+        /**< INTERNAL ONLY */
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_VOID_N(z, n, data)                                               \
+        typedef mpl::void_ BOOST_PP_CAT(child, n);                                              \
+        /**< INTERNAL ONLY */
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/args.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file args.hpp
+    /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
+    /// class templates.
+    //
+    //  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
+
+    /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+    ///
+    /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+    /// The types in the sequence correspond to the children of a node in an expression tree.
+    template< typename Arg0 >
+    struct term
+    {
+        static const long arity = 0;
+        typedef Arg0 child0;
+        BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
+
+        /// INTERNAL ONLY
+        ///
+        typedef Arg0 back_;
+    };
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                         \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/args.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEFINE_VOID_N
+    #undef BOOST_PROTO_DEFINE_CHILD_N
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+    ///
+    /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+    /// The types in the sequence correspond to the children of a node in an expression tree.
+    template< BOOST_PP_ENUM_PARAMS(N, typename Arg) >
+    struct BOOST_PP_CAT(list, N)
+    {
+        static const long arity = N;
+        BOOST_PP_REPEAT(N, BOOST_PROTO_DEFINE_CHILD_N, ~)
+        BOOST_PP_REPEAT_FROM_TO(N, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
+
+        /// INTERNAL ONLY
+        ///
+        typedef BOOST_PP_CAT(Arg, BOOST_PP_DEC(N)) back_;
+    };
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/as_expr.hpp

@@ -0,0 +1,187 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file as_expr.hpp
+/// Contains definition of the as_expr\<\> and as_child\<\> helper class
+/// templates used to implement proto::domain's as_expr\<\> and as_child\<\>
+/// member templates.
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010
+#define BOOST_PROTO_DETAIL_AS_EXPR_HPP_EAN_06_09_2010
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/args.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto { namespace detail
+{
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename Generator>
+    struct base_generator
+    {
+        typedef Generator type;
+    };
+
+    template<typename Generator>
+    struct base_generator<use_basic_expr<Generator> >
+    {
+        typedef Generator type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator, bool WantsBasicExpr>
+    struct as_expr;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator>
+    struct as_expr<T, Generator, false>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::expr<proto::tag::terminal, term<value_type>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator>
+    struct as_expr<T, Generator, true>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct as_expr<T, proto::default_generator, false>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::expr<proto::tag::terminal, term<value_type>, 0> result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct as_expr<T, proto::default_generator, true>
+    {
+        typedef typename term_traits<T &>::value_type value_type;
+        typedef proto::basic_expr<proto::tag::terminal, term<value_type>, 0> result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator, bool WantsBasicExpr>
+    struct as_child;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator>
+    struct as_child<T, Generator, false>
+    {
+    #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+        typedef typename term_traits<T &>::reference reference;
+    #else
+        typedef T &reference;
+    #endif
+        typedef proto::expr<proto::tag::terminal, term<reference>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Generator>
+    struct as_child<T, Generator, true>
+    {
+    #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+        typedef typename term_traits<T &>::reference reference;
+    #else
+        typedef T &reference;
+    #endif
+        typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> expr_type;
+        typedef typename Generator::template result<Generator(expr_type)>::type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return Generator()(expr_type::make(t));
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct as_child<T, proto::default_generator, false>
+    {
+    #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+        typedef typename term_traits<T &>::reference reference;
+    #else
+        typedef T &reference;
+    #endif
+        typedef proto::expr<proto::tag::terminal, term<reference>, 0> result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct as_child<T, proto::default_generator, true>
+    {
+    #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+        typedef typename term_traits<T &>::reference reference;
+    #else
+        typedef T &reference;
+    #endif
+        typedef proto::basic_expr<proto::tag::terminal, term<reference>, 0> result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(T &t) const
+        {
+            return result_type::make(t);
+        }
+    };
+
+}}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/as_lvalue.hpp

@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file as_lvalue.hpp
+/// Contains definition the as_lvalue() functions.
+//
+//  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)
+
+#ifndef BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
+#define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
+
+#include <boost/proto/proto_fwd.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        BOOST_FORCEINLINE
+        T &as_lvalue(T &t)
+        {
+            return t;
+        }
+
+        template<typename T>
+        BOOST_FORCEINLINE
+        T const &as_lvalue(T const &t)
+        {
+            return t;
+        }
+    }
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/basic_expr.hpp

@@ -0,0 +1,185 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/basic_expr.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_CHILD(Z, N, DATA)                                                       \
+        typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N);                              \
+        BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N);                                    \
+        /**< INTERNAL ONLY */
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_VOID(Z, N, DATA)                                                        \
+        typedef void BOOST_PP_CAT(proto_child, N);                                              \
+        /**< INTERNAL ONLY */
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/basic_expr.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file basic_expr.hpp
+    /// Contains definition of basic_expr\<\> 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
+
+    // The expr<> specializations are actually defined here.
+    #define BOOST_PROTO_DEFINE_TERMINAL
+    #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/basic_expr.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #undef BOOST_PROTO_DEFINE_TERMINAL
+    #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/basic_expr.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_CHILD
+    #undef BOOST_PROTO_VOID
+
+#else
+
+    #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION())
+
+    /// \brief Simplified representation of a node in an expression tree.
+    ///
+    /// \c proto::basic_expr\<\> is a node in an expression template tree. It
+    /// is a container for its child sub-trees. It also serves as
+    /// the terminal nodes of the tree.
+    ///
+    /// \c Tag is type that represents the operation encoded by
+    ///             this expression. It is typically one of the structs
+    ///             in the \c boost::proto::tag namespace, but it doesn't
+    ///             have to be.
+    ///
+    /// \c Args is a type list representing the type of the children
+    ///             of this expression. It is an instantiation of one
+    ///             of \c proto::list1\<\>, \c proto::list2\<\>, etc. The
+    ///             child types must all themselves be either \c expr\<\>
+    ///             or <tt>proto::expr\<\>&</tt>. If \c Args is an
+    ///             instantiation of \c proto::term\<\> then this
+    ///             \c expr\<\> type represents a terminal expression;
+    ///             the parameter to the \c proto::term\<\> template
+    ///             represents the terminal's value type.
+    ///
+    /// \c Arity is an integral constant representing the number of child
+    ///             nodes this node contains. If \c Arity is 0, then this
+    ///             node is a terminal.
+    ///
+    /// \c proto::basic_expr\<\> is a valid Fusion random-access sequence, where
+    /// the elements of the sequence are the child expressions.
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+    template<typename Tag, typename Arg0>
+    struct basic_expr<Tag, term<Arg0>, 0>
+    #else
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)>
+    struct basic_expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() >
+    #endif
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = BOOST_PP_ITERATION();
+        typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity;
+        typedef basic_expr proto_base_expr;
+        #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        typedef term<Arg0> proto_args;
+        #else
+        typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
+        #endif
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; /**< INTERNAL ONLY */
+
+        BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~)
+        BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~)
+
+        /// \return *this
+        ///
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+
+        /// \overload
+        ///
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \return A new \c expr\<\> object initialized with the specified
+        /// arguments.
+        ///
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+
+        /// \overload
+        ///
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+    #else
+        /// \return A new \c expr\<\> object initialized with the specified
+        /// arguments.
+        ///
+        template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)>
+        BOOST_FORCEINLINE
+        static basic_expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a))
+        {
+            basic_expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)};
+            return that;
+        }
+    #endif
+
+    #if 1 == BOOST_PP_ITERATION()
+        /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is
+        /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>.
+        /// Otherwise, it is some undefined type.
+        typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
+
+        /// \return The address of <tt>this->child0</tt> if \c Tag is
+        /// \c boost::proto::tag::address_of. Otherwise, this function will
+        /// fail to compile.
+        ///
+        /// \attention Proto overloads <tt>operator&</tt>, which means that
+        /// proto-ified objects cannot have their addresses taken, unless we use
+        /// the following hack to make \c &x implicitly convertible to \c X*.
+        BOOST_FORCEINLINE
+        operator address_of_hack_type_() const
+        {
+            return boost::addressof(this->child0);
+        }
+    #else
+        /// INTERNAL ONLY
+        ///
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    #endif
+    };
+
+#undef ARG_COUNT
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/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

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/decltype.hpp

@@ -0,0 +1,453 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file decltype.hpp
+/// Contains definition the BOOST_PROTO_DECLTYPE_() macro and assorted helpers
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
+#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/type_traits/is_member_object_pointer.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/detail/any.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+// We're STILL using Boost.Typeof on MSVC even for msvc-11.0 because of this bug:
+// https://connect.microsoft.com/VisualStudio/feedback/details/765392/decltype-of-a-pointer-to-member-operator-gets-ref-qualification-wrong
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1700))
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype((EXPR)) TYPE;
+#else
+# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR)                                     \
+    BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR)                 \
+    static int const BOOST_PP_CAT(sz, NESTED) = sizeof(boost::proto::detail::check_reference(EXPR));\
+    struct NESTED                                                                                   \
+      : boost::mpl::if_c<                                                                           \
+            1 == BOOST_PP_CAT(sz, NESTED)                                                           \
+          , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type &                               \
+          , typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type                                 \
+        >                                                                                           \
+    {};
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE)                                                          \
+    BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR))                   \
+    typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        struct as_mutable
+        {
+            typedef T &type;
+        };
+
+        template<typename T>
+        struct as_mutable<T &>
+        {
+            typedef T &type;
+        };
+
+        template<typename T>
+        struct as_mutable<T const &>
+        {
+            typedef T &type;
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        T make();
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        typename as_mutable<T>::type make_mutable();
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        struct subscript_wrapper
+          : T
+        {
+            using T::operator[];
+
+            #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+            any operator[](any const volatile &) const volatile;
+            #else
+            any operator[](any const &) const volatile;
+            #endif
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        struct as_subscriptable
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T>
+                  , T
+                >::type
+            type;
+        };
+
+        template<typename T>
+        struct as_subscriptable<T const>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> const
+                  , T const
+                >::type
+            type;
+        };
+
+        template<typename T>
+        struct as_subscriptable<T &>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> &
+                  , T &
+                >::type
+            type;
+        };
+
+        template<typename T>
+        struct as_subscriptable<T const &>
+        {
+            typedef
+                typename mpl::if_c<
+                    is_class<T>::value
+                  , subscript_wrapper<T> const &
+                  , T const &
+                >::type
+            type;
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        typename as_subscriptable<T>::type make_subscriptable();
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        char check_reference(T &);
+
+        template<typename T>
+        char (&check_reference(T const &))[2];
+
+        namespace has_get_pointerns
+        {
+            using boost::get_pointer;
+            void *(&get_pointer(...))[2];
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            template<typename T>
+            struct has_get_pointer
+            {
+                static const bool value = sizeof(void *) == sizeof(get_pointer(make<T &>()));
+                typedef mpl::bool_<value> type;
+            };
+        }
+
+        using has_get_pointerns::has_get_pointer;
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        struct class_member_traits;
+
+        template<typename T, typename U>
+        struct class_member_traits<T U::*>
+        {
+            typedef U class_type;
+            typedef T result_type;
+        };
+
+        // Other specializations are generated by the preprocessor
+        #include <boost/proto/detail/class_member_traits.hpp>
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename T>
+        T &lvalue(T &t)
+        {
+            return t;
+        }
+
+        template<typename T>
+        T const &lvalue(T const &t)
+        {
+            return t;
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename U, typename V, typename T>
+        U *proto_get_pointer(T &t, V *, U *)
+        {
+            return boost::addressof(t);
+        }
+
+        template<typename U, typename V, typename T>
+        U const *proto_get_pointer(T &t, V *, U const *)
+        {
+            return boost::addressof(t);
+        }
+
+        template<typename U, typename V, typename T>
+        V *proto_get_pointer(T &t, V *, ...)
+        {
+            return get_pointer(t);
+        }
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        #define BOOST_PROTO_USE_GET_POINTER()                                                       \
+        using namespace boost::proto::detail::get_pointerns                                         \
+        /**/
+
+        #define BOOST_PROTO_GET_POINTER(Type, Obj)                                                  \
+        boost::proto::detail::proto_get_pointer<Type>(                                              \
+            boost::proto::detail::lvalue(Obj)                                                       \
+          , (true ? 0 : get_pointer(Obj))                                                           \
+          , (true ? 0 : boost::addressof(boost::proto::detail::lvalue(Obj)))                        \
+        )                                                                                           \
+        /**/
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        namespace get_pointerns
+        {
+            using boost::get_pointer;
+
+            template<typename T>
+            typename disable_if_c<has_get_pointer<T>::value, T *>::type
+            get_pointer(T &t)
+            {
+                return boost::addressof(t);
+            }
+
+            template<typename T>
+            typename disable_if_c<has_get_pointer<T>::value, T const *>::type
+            get_pointer(T const &t)
+            {
+                return boost::addressof(t);
+            }
+
+            char test_ptr_to_const(void *);
+            char (&test_ptr_to_const(void const *))[2];
+
+            template<typename U> char test_V_is_a_U(U *);
+            template<typename U> char test_V_is_a_U(U const *);
+            template<typename U> char (&test_V_is_a_U(...))[2];
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            // result_of_ is a wrapper around boost::result_of that also handles "invocations" of
+            // member object pointers.
+            template<typename T, typename Void = void>
+            struct result_of_
+              : BOOST_PROTO_RESULT_OF<T>
+            {};
+
+            template<typename T, typename U, typename V>
+            struct result_of_<T U::*(V), typename enable_if_c<is_member_object_pointer<T U::*>::value>::type>
+            {
+                static const bool is_V_a_smart_ptr = 2 == sizeof(test_V_is_a_U<U>(&lvalue(make<V>())));
+                static const bool is_ptr_to_const = 2 == sizeof(test_ptr_to_const(BOOST_PROTO_GET_POINTER(U, make<V>())));
+
+                // If V is not a U, then it is a (smart) pointer and we can always return an lvalue.
+                // Otherwise, we can only return an lvalue if we are given one.
+                typedef
+                    typename mpl::eval_if_c<
+                        (is_V_a_smart_ptr || is_reference<V>::value)
+                      , mpl::eval_if_c<
+                            is_ptr_to_const
+                          , add_reference<typename add_const<T>::type>
+                          , add_reference<T>
+                        >
+                      , mpl::identity<T>
+                    >::type
+                type;
+            };
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            template<
+                typename T
+              , typename U
+              , bool IsMemPtr = is_member_object_pointer<
+                    typename remove_reference<U>::type
+                >::value
+            >
+            struct mem_ptr_fun
+            {
+                BOOST_PROTO_DECLTYPE_(
+                    proto::detail::make_mutable<T>() ->* proto::detail::make<U>()
+                  , result_type
+                )
+
+                result_type operator()(
+                    typename add_reference<typename add_const<T>::type>::type t
+                  , typename add_reference<typename add_const<U>::type>::type u
+                ) const
+                {
+                    return t ->* u;
+                }
+            };
+
+            ////////////////////////////////////////////////////////////////////////////////////////////
+            template<typename T, typename U>
+            struct mem_ptr_fun<T, U, true>
+            {
+                typedef
+                    typename class_member_traits<
+                        typename uncvref<U>::type
+                    >::class_type
+                V;
+
+                BOOST_PROTO_DECLTYPE_(
+                    BOOST_PROTO_GET_POINTER(V, proto::detail::make_mutable<T>()) ->* proto::detail::make<U>()
+                  , result_type
+                )
+
+                result_type operator()(
+                    typename add_reference<typename add_const<T>::type>::type t
+                  , U u
+                ) const
+                {
+                    return BOOST_PROTO_GET_POINTER(V, t) ->* u;
+                }
+            };
+        }
+
+        using get_pointerns::result_of_;
+        using get_pointerns::mem_ptr_fun;
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        template<typename A0, typename A1>
+        struct comma_result
+        {
+            BOOST_PROTO_DECLTYPE_((proto::detail::make<A0>(), proto::detail::make<A1>()), type)
+        };
+
+        template<typename A0>
+        struct comma_result<A0, void>
+        {
+            typedef void type;
+        };
+
+        template<typename A1>
+        struct comma_result<void, A1>
+        {
+            typedef A1 type;
+        };
+
+        template<>
+        struct comma_result<void, void>
+        {
+            typedef void type;
+        };
+
+        ////////////////////////////////////////////////////////////////////////////////////////////
+        // normalize a function type for use with boost::result_of
+        template<typename T, typename U = T>
+        struct result_of_fixup
+          : mpl::if_c<is_function<T>::value, T *, U>
+        {};
+
+        template<typename T, typename U>
+        struct result_of_fixup<T &, U>
+          : result_of_fixup<T, T>
+        {};
+
+        template<typename T, typename U>
+        struct result_of_fixup<T const &, U>
+          : result_of_fixup<T, T>
+        {};
+
+        template<typename T, typename U>
+        struct result_of_fixup<T *, U>
+          : result_of_fixup<T, U>
+        {};
+
+        template<typename R, typename T, typename U>
+        struct result_of_fixup<R T::*, U>
+        {
+            typedef R T::*type;
+        };
+
+        template<typename T, typename U>
+        struct result_of_fixup<T const, U>
+          : result_of_fixup<T, U>
+        {};
+
+        //// Tests for result_of_fixup
+        //struct bar {};
+        //BOOST_MPL_ASSERT((is_same<bar,        result_of_fixup<bar>::type>));
+        //BOOST_MPL_ASSERT((is_same<bar const,  result_of_fixup<bar const>::type>));
+        //BOOST_MPL_ASSERT((is_same<bar,        result_of_fixup<bar &>::type>));
+        //BOOST_MPL_ASSERT((is_same<bar const,  result_of_fixup<bar const &>::type>));
+        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(*)()>::type>));
+        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(* const)()>::type>));
+        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(* const &)()>::type>));
+        //BOOST_MPL_ASSERT((is_same<void(*)(),  result_of_fixup<void(&)()>::type>));
+
+        template<typename T, typename PMF>
+        struct memfun
+        {
+            typedef typename uncvref<PMF>::type pmf_type;
+            typedef typename class_member_traits<pmf_type>::class_type V;
+            typedef typename class_member_traits<pmf_type>::result_type result_type;
+
+            memfun(T t, pmf_type p)
+              : obj(t)
+              , pmf(p)
+            {}
+
+            result_type operator()() const
+            {
+                BOOST_PROTO_USE_GET_POINTER();
+                return (BOOST_PROTO_GET_POINTER(V, obj) ->* pmf)();
+            }
+
+            // Other overloads generated by the preprocessor
+            #include <boost/proto/detail/memfun_funop.hpp>
+
+        private:
+            T obj;
+            pmf_type pmf;
+        };
+
+    } // namespace detail
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/deduce_domain.hpp

@@ -0,0 +1,200 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file deduce_domain.hpp
+/// Contains definition of deduce_domain\<\> class templates 
+/// for finding the domain that is common among the specified
+/// domains
+//
+//  Copyright 2010 Daniel Wallin, 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)
+//
+// Many thanks to Daniel Wallin who first implemented this code. Thanks
+// also to Jeremiah Willcock, John Bytheway and Krishna Achuthan who
+// offered alternate solutions to this tricky programming problem.
+
+#ifndef BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010
+#define BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+#ifndef BOOST_PROTO_ASSERT_VALID_DOMAIN
+# define BOOST_PROTO_ASSERT_VALID_DOMAIN(DOM) BOOST_MPL_ASSERT_NOT((boost::is_same<DOM, boost::proto::detail::not_a_domain>))
+#endif
+
+namespace boost
+{
+    namespace proto
+    {
+        namespace detail
+        {
+            template<typename Domain>
+            struct domain_
+              : domain_<typename Domain::proto_super_domain>
+            {
+                typedef Domain type;
+                typedef domain_<typename Domain::proto_super_domain> base;
+            #ifdef BOOST_NO_CXX11_DECLTYPE
+                using base::deduce98;
+                static int const index = base::index + 1;
+                static typename sized_type<index>::type deduce98(domain_<Domain>*);
+            #else
+                using base::deduce0x;
+                static Domain deduce0x(domain_<Domain>*);
+            #endif
+            };
+
+            template<>
+            struct domain_<not_a_domain>
+            {
+                typedef not_a_domain type;
+            #ifdef BOOST_NO_CXX11_DECLTYPE
+                static int const index = 1;
+                static sized_type<1>::type deduce98(void*);
+            #else
+                static not_a_domain deduce0x(void*);
+            #endif
+            };
+
+            template<>
+            struct domain_<default_domain>
+              : domain_<not_a_domain>
+            {};
+
+            template<>
+            struct domain_<basic_default_domain>
+              : domain_<not_a_domain>
+            {};
+
+            sized_type<1>::type default_test(void*, void*);
+            sized_type<2>::type default_test(domain_<default_domain>*, void*);
+            sized_type<2>::type default_test(domain_<basic_default_domain>*, void*);
+            sized_type<3>::type default_test(void*, domain_<default_domain>*);
+            sized_type<3>::type default_test(void*, domain_<basic_default_domain>*);
+            sized_type<4>::type default_test(domain_<default_domain>*, domain_<default_domain>*);
+            sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<default_domain>*);
+            sized_type<4>::type default_test(domain_<default_domain>*, domain_<basic_default_domain>*);
+            sized_type<4>::type default_test(domain_<basic_default_domain>*, domain_<basic_default_domain>*);
+
+        #ifdef BOOST_NO_CXX11_DECLTYPE
+            template<int N, typename Domain>
+            struct nth_domain
+              : nth_domain<N - 1, typename Domain::base>
+            {};
+
+            template<typename Domain>
+            struct nth_domain<0, Domain>
+              : Domain
+            {};
+        #endif
+
+            template<typename D0>
+            struct common_domain1
+            {
+                typedef D0 type;
+            };
+
+            template<typename E0>
+            struct deduce_domain1
+              : domain_of<E0>
+            {};
+
+            template<
+                typename D0
+              , typename D1
+              , int DefaultCase = sizeof(proto::detail::default_test((domain_<D0>*)0, (domain_<D1>*)0))
+            >
+            struct common_domain2
+            {
+            #ifdef BOOST_NO_CXX11_DECLTYPE
+                static int const index = domain_<D0>::index - sizeof(domain_<D0>::deduce98((domain_<D1>*)0));
+                typedef typename nth_domain<index, domain_<D0> >::type type;
+            #else
+                typedef decltype(domain_<D0>::deduce0x((domain_<D1>*)0)) type;
+            #endif
+            };
+
+            template<typename D0, typename D1>
+            struct common_domain2<D0, D1, 2>
+            {
+                typedef D1 type;
+            };
+
+            template<typename D0, typename D1>
+            struct common_domain2<D0, D1, 3>
+            {
+                typedef D0 type;
+            };
+
+            template<typename D0>
+            struct common_domain2<D0, default_domain, 4>
+            {
+                typedef D0 type;
+            };
+
+            template<typename D0>
+            struct common_domain2<D0, basic_default_domain, 4>
+            {
+                typedef D0 type;
+            };
+
+            template<typename D1>
+            struct common_domain2<default_domain, D1, 4>
+            {
+                typedef D1 type;
+            };
+
+            template<typename D1>
+            struct common_domain2<basic_default_domain, D1, 4>
+            {
+                typedef D1 type;
+            };
+
+            template<>
+            struct common_domain2<default_domain, default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+
+            template<>
+            struct common_domain2<basic_default_domain, default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+
+            template<>
+            struct common_domain2<default_domain, basic_default_domain, 4>
+            {
+                typedef default_domain type;
+            };
+
+            template<>
+            struct common_domain2<basic_default_domain, basic_default_domain, 4>
+            {
+                typedef basic_default_domain type;
+            };
+
+            template<typename E0, typename E1>
+            struct deduce_domain2
+              : common_domain2<
+                    typename domain_of<E0>::type
+                  , typename domain_of<E1>::type
+                >
+            {};
+
+            #include <boost/proto/detail/deduce_domain_n.hpp>
+        }
+    }
+}
+
+#endif // BOOST_PROTO_DEDUCE_DOMAIN_HPP_EAN_05_22_2010

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/deduce_domain_n.hpp

@@ -0,0 +1,64 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/deduce_domain_n.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_COMMON_DOMAIN2(Z, N, DATA)                                                  \
+        typedef                                                                                     \
+            typename common_domain2<common ## N, A ## N>::type                                      \
+        BOOST_PP_CAT(common, BOOST_PP_INC(N));                                                      \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deduce_domain_n.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // deduce_domain_n.hpp
+    // Definitions of common_domain[n] and deduce_domain[n] class templates.
+    //
+    //  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/detail/deduce_domain_n.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_COMMON_DOMAIN2
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+    struct BOOST_PP_CAT(common_domain, N)
+    {
+        typedef A0 common1;
+        BOOST_PP_REPEAT_FROM_TO(1, N, BOOST_PROTO_COMMON_DOMAIN2, ~)
+        typedef BOOST_PP_CAT(common, N) type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+
+    template<BOOST_PP_ENUM_PARAMS(N, typename E)>
+    struct BOOST_PP_CAT(deduce_domain, N)
+      : BOOST_PP_CAT(common_domain, N)<
+            BOOST_PP_ENUM_BINARY_PARAMS(
+                N
+              , typename domain_of<E, >::type BOOST_PP_INTERCEPT
+            )
+        >
+    {};
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/deep_copy.hpp

@@ -0,0 +1,79 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/deep_copy.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_DEFINE_DEEP_COPY_TYPE(Z, N, DATA)                                           \
+        typename deep_copy_impl<                                                                    \
+            typename remove_reference<                                                              \
+                typename Expr::BOOST_PP_CAT(proto_child, N)                                         \
+            >::type::proto_derived_expr                                                             \
+        >::result_type                                                                              \
+        /**/
+
+    #define BOOST_PROTO_DEFINE_DEEP_COPY_FUN(Z, N, DATA)                                            \
+        proto::deep_copy(e.proto_base().BOOST_PP_CAT(child, N))                                     \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/deep_copy.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file deep_copy.hpp
+    /// Replace all nodes stored by reference by nodes stored by value.
+    //
+    //  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/deep_copy.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEFINE_DEEP_COPY_FUN
+    #undef BOOST_PROTO_DEFINE_DEEP_COPY_TYPE
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Expr>
+    struct deep_copy_impl<Expr, N>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , BOOST_PP_CAT(list, N)<
+                    BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_TYPE, ~)
+                >
+            >::type
+        expr_type;
+
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~)
+            };
+
+            return proto_generator()(that);
+        }
+    };
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/deprecated.hpp

@@ -0,0 +1,247 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file deprecated.hpp
+/// Definition of the deprecated BOOST_PROTO_DEFINE_FUCTION_TEMPLATE and
+/// BOOST_PROTO_DEFINE_VARARG_FUCTION_TEMPLATE macros
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
+#define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/control/expr_if.hpp>
+#include <boost/preprocessor/comparison/greater.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/tuple/to_list.hpp>
+#include <boost/preprocessor/logical/and.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/seq/enum.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/to_tuple.hpp>
+#include <boost/preprocessor/seq/for_each_i.hpp>
+#include <boost/preprocessor/seq/pop_back.hpp>
+#include <boost/preprocessor/seq/push_back.hpp>
+#include <boost/preprocessor/seq/push_front.hpp>
+#include <boost/preprocessor/list/for_each_i.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TEMPLATE_AUX_(R, DATA, I, ELEM)                                      \
+    (ELEM BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I)))                              \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TEMPLATE_YES_(R, DATA, I, ELEM)                                      \
+    BOOST_PP_LIST_FOR_EACH_I_R(                                                                 \
+        R                                                                                       \
+      , BOOST_PROTO_VARARG_TEMPLATE_AUX_                                                        \
+      , I                                                                                       \
+      , BOOST_PP_TUPLE_TO_LIST(                                                                 \
+            BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                               \
+          , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM))                                      \
+        )                                                                                       \
+    )                                                                                           \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TEMPLATE_NO_(R, DATA, I, ELEM)                                       \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TEMPLATE_(R, DATA, I, ELEM)                                          \
+    BOOST_PP_IF(                                                                                \
+        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                                   \
+      , BOOST_PROTO_VARARG_TEMPLATE_YES_                                                        \
+      , BOOST_PROTO_VARARG_TEMPLATE_NO_                                                         \
+    )(R, DATA, I, ELEM)                                                                         \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TYPE_AUX_(R, DATA, I, ELEM)                                          \
+    (BOOST_PP_CAT(BOOST_PP_CAT(X, DATA), BOOST_PP_CAT(_, I)))                                   \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_TEMPLATE_PARAMS_YES_(R, DATA, I, ELEM)                                      \
+    <                                                                                           \
+        BOOST_PP_SEQ_ENUM(                                                                      \
+            BOOST_PP_LIST_FOR_EACH_I_R(                                                         \
+                R                                                                               \
+              , BOOST_PROTO_VARARG_TYPE_AUX_                                                    \
+              , I                                                                               \
+              , BOOST_PP_TUPLE_TO_LIST(                                                         \
+                    BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                       \
+                  , BOOST_PP_SEQ_TO_TUPLE(BOOST_PP_SEQ_TAIL(ELEM))                              \
+                )                                                                               \
+            )                                                                                   \
+        )                                                                                       \
+    >                                                                                           \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_TEMPLATE_PARAMS_NO_(R, DATA, I, ELEM)                                       \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM)                                              \
+    BOOST_PP_COMMA_IF(I)                                                                        \
+    BOOST_PP_SEQ_HEAD(ELEM)                                                                     \
+    BOOST_PP_IF(                                                                                \
+        BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                                   \
+      , BOOST_PROTO_TEMPLATE_PARAMS_YES_                                                        \
+      , BOOST_PROTO_TEMPLATE_PARAMS_NO_                                                         \
+    )(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const)                         \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM)                                           \
+    BOOST_PP_EXPR_IF(                                                                           \
+        BOOST_PP_GREATER(I, 1)                                                                  \
+      , ((                                                                                      \
+            BOOST_PP_SEQ_HEAD(ELEM)                                                             \
+            BOOST_PP_IF(                                                                        \
+                BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))                                           \
+              , BOOST_PROTO_TEMPLATE_PARAMS_YES_                                                \
+              , BOOST_PROTO_TEMPLATE_PARAMS_NO_                                                 \
+            )(R, DATA, I, ELEM)()                                                               \
+        ))                                                                                      \
+    )                                                                                           \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_AS_CHILD_(Z, N, DATA)                                                \
+    (BOOST_PP_CAT(DATA, N))                                                                     \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_SEQ_PUSH_FRONT(SEQ, ELEM)                                                   \
+    BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ, _dummy_), ELEM))  \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA)                                                \
+    (BOOST_PP_CAT(DATA, N))                                                                     \
+    /**/
+
+/// INTERNAL ONLY
+///
+#define BOOST_PROTO_VARARG_FUN_(Z, N, DATA)                                                     \
+    template<                                                                                   \
+        BOOST_PP_SEQ_ENUM(                                                                      \
+            BOOST_PP_SEQ_FOR_EACH_I(                                                            \
+                BOOST_PROTO_VARARG_TEMPLATE_, ~                                                 \
+              , BOOST_PP_SEQ_PUSH_FRONT(                                                        \
+                    BOOST_PROTO_SEQ_PUSH_FRONT(                                                 \
+                        BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                         \
+                      , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                       \
+                    )                                                                           \
+                  , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                             \
+                )                                                                               \
+            )                                                                                   \
+            BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_, typename A)                  \
+        )                                                                                       \
+    >                                                                                           \
+    typename boost::proto::result_of::make_expr<                                                \
+        BOOST_PP_SEQ_FOR_EACH_I(                                                                \
+            BOOST_PROTO_VARARG_TYPE_, ~                                                         \
+          , BOOST_PP_SEQ_PUSH_FRONT(                                                            \
+                BOOST_PROTO_SEQ_PUSH_FRONT(                                                     \
+                    BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                             \
+                  , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                           \
+                )                                                                               \
+              , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                                 \
+            )                                                                                   \
+        )                                                                                       \
+        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT)             \
+    >::type const                                                                               \
+    BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a))           \
+    {                                                                                           \
+        return boost::proto::detail::make_expr_<                                                \
+            BOOST_PP_SEQ_FOR_EACH_I(                                                            \
+                BOOST_PROTO_VARARG_TYPE_, ~                                                     \
+              , BOOST_PP_SEQ_PUSH_FRONT(                                                        \
+                    BOOST_PROTO_SEQ_PUSH_FRONT(                                                 \
+                        BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                         \
+                      , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                       \
+                    )                                                                           \
+                  , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                             \
+                )                                                                               \
+            )                                                                                   \
+            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(Z, N, A, const & BOOST_PP_INTERCEPT)         \
+        >()(                                                                                    \
+            BOOST_PP_SEQ_ENUM(                                                                  \
+                BOOST_PP_SEQ_FOR_EACH_I(                                                        \
+                    BOOST_PROTO_VARARG_AS_EXPR_, ~                                              \
+                  , BOOST_PP_SEQ_PUSH_FRONT(                                                    \
+                        BOOST_PROTO_SEQ_PUSH_FRONT(                                             \
+                            BOOST_PP_TUPLE_ELEM(4, 2, DATA)                                     \
+                          , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))                                   \
+                        )                                                                       \
+                      , BOOST_PP_TUPLE_ELEM(4, 1, DATA)                                         \
+                    )                                                                           \
+                )                                                                               \
+                BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_CHILD_, a)                       \
+            )                                                                                   \
+        );                                                                                      \
+    }                                                                                           \
+    /**/
+
+/// \code
+/// BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
+///     1
+///   , construct
+///   , boost::proto::default_domain
+///   , (boost::proto::tag::function)
+///   , ((op::construct)(typename)(int))
+/// )
+/// \endcode
+#define BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(ARGCOUNT, NAME, DOMAIN, TAG, BOUNDARGS)            \
+    BOOST_PP_REPEAT_FROM_TO(                                                                    \
+        ARGCOUNT                                                                                \
+      , BOOST_PP_INC(ARGCOUNT)                                                                  \
+      , BOOST_PROTO_VARARG_FUN_                                                                 \
+      , (NAME, TAG, BOUNDARGS, DOMAIN)                                                          \
+    )\
+    /**/
+
+/// \code
+/// BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(
+///     construct
+///   , boost::proto::default_domain
+///   , (boost::proto::tag::function)
+///   , ((op::construct)(typename)(int))
+/// )
+/// \endcode
+#define BOOST_PROTO_DEFINE_VARARG_FUNCTION_TEMPLATE(NAME, DOMAIN, TAG, BOUNDARGS)               \
+    BOOST_PP_REPEAT(                                                                            \
+        BOOST_PP_SUB(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), BOOST_PP_SEQ_SIZE(BOUNDARGS))         \
+      , BOOST_PROTO_VARARG_FUN_                                                                 \
+      , (NAME, TAG, BOUNDARGS, DOMAIN)                                                          \
+    )                                                                                           \
+    /**/
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/dont_care.hpp

@@ -0,0 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file dont_care.hpp
+/// Definintion of dont_care, a dummy parameter
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_DONT_CARE_HPP_EAN_11_07_2007
+#define BOOST_PROTO_DETAIL_DONT_CARE_HPP_EAN_11_07_2007
+
+#include <boost/config.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        struct dont_care
+        {
+            BOOST_FORCEINLINE dont_care(...);
+        };
+    }
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/expr.hpp

@@ -0,0 +1,474 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        #include <boost/proto/detail/preprocessed/expr_variadic.hpp>
+    #else
+        #include <boost/proto/detail/preprocessed/expr.hpp>
+    #endif
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_CHILD(Z, N, DATA)                                                       \
+        typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(proto_child, N);                              \
+        BOOST_PP_CAT(proto_child, N) BOOST_PP_CAT(child, N);                                    \
+        /**< INTERNAL ONLY */
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_VOID(Z, N, DATA)                                                        \
+        typedef void BOOST_PP_CAT(proto_child, N);                                              \
+        /**< INTERNAL ONLY */
+
+    // Generate variadic versions of expr
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr_variadic.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file expr_variadic.hpp
+    /// Contains definition of expr\<\> 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
+
+    // The expr<> specializations are actually defined here.
+    #define BOOST_PROTO_DEFINE_TERMINAL
+    #define BOOST_PP_ITERATION_PARAMS_1                                                         \
+        (3, (0, 0, <boost/proto/detail/expr.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #undef BOOST_PROTO_DEFINE_TERMINAL
+    #define BOOST_PP_ITERATION_PARAMS_1                                                         \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    // Generate non-variadic versions of expr
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expr.hpp")
+
+        ///////////////////////////////////////////////////////////////////////////////
+        /// \file expr.hpp
+        /// Contains definition of expr\<\> 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)
+
+        #pragma wave option(preserve: 1)
+
+        // The expr<> specializations are actually defined here.
+        #define BOOST_PROTO_DEFINE_TERMINAL
+        #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, 0, <boost/proto/detail/expr.hpp>))
+        #include BOOST_PP_ITERATE()
+
+        #undef BOOST_PROTO_DEFINE_TERMINAL
+        #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/expr.hpp>))
+        #include BOOST_PP_ITERATE()
+
+        #pragma wave option(output: null)
+        #undef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+    #endif
+
+    #undef BOOST_PROTO_CHILD
+    #undef BOOST_PROTO_VOID
+
+#else
+
+    #define ARG_COUNT BOOST_PP_MAX(1, BOOST_PP_ITERATION())
+
+    /// \brief Representation of a node in an expression tree.
+    ///
+    /// \c proto::expr\<\> is a node in an expression template tree. It
+    /// is a container for its child sub-trees. It also serves as
+    /// the terminal nodes of the tree.
+    ///
+    /// \c Tag is type that represents the operation encoded by
+    ///             this expression. It is typically one of the structs
+    ///             in the \c boost::proto::tag namespace, but it doesn't
+    ///             have to be.
+    ///
+    /// \c Args is a type list representing the type of the children
+    ///             of this expression. It is an instantiation of one
+    ///             of \c proto::list1\<\>, \c proto::list2\<\>, etc. The
+    ///             child types must all themselves be either \c expr\<\>
+    ///             or <tt>proto::expr\<\>&</tt>. If \c Args is an
+    ///             instantiation of \c proto::term\<\> then this
+    ///             \c expr\<\> type represents a terminal expression;
+    ///             the parameter to the \c proto::term\<\> template
+    ///             represents the terminal's value type.
+    ///
+    /// \c Arity is an integral constant representing the number of child
+    ///             nodes this node contains. If \c Arity is 0, then this
+    ///             node is a terminal.
+    ///
+    /// \c proto::expr\<\> is a valid Fusion random-access sequence, where
+    /// the elements of the sequence are the child expressions.
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+    template<typename Tag, typename Arg0>
+    struct expr<Tag, term<Arg0>, 0>
+    #else
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(ARG_COUNT, typename Arg)>
+    struct expr<Tag, BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)>, BOOST_PP_ITERATION() >
+    #endif
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = BOOST_PP_ITERATION();
+        typedef mpl::long_<BOOST_PP_ITERATION() > proto_arity;
+        typedef expr proto_base_expr;
+        #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        typedef term<Arg0> proto_args;
+        #else
+        typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
+        #endif
+        typedef basic_expr<Tag, proto_args, BOOST_PP_ITERATION() > proto_grammar;
+        typedef default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef expr proto_derived_expr;
+        typedef void proto_is_expr_; /**< INTERNAL ONLY */
+
+        BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_CHILD, ~)
+        BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~)
+
+        /// \return *this
+        ///
+        BOOST_FORCEINLINE
+        expr const &proto_base() const
+        {
+            return *this;
+        }
+
+        /// \overload
+        ///
+        BOOST_FORCEINLINE
+        expr &proto_base()
+        {
+            return *this;
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \return A new \c expr\<\> object initialized with the specified
+        /// arguments.
+        ///
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static expr const make(A0 &a0)
+        {
+            return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
+        }
+
+        /// \overload
+        ///
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static expr const make(A0 const &a0)
+        {
+            return detail::make_terminal(a0, static_cast<expr *>(0), static_cast<proto_args *>(0));
+        }
+    #else
+        /// \return A new \c expr\<\> object initialized with the specified
+        /// arguments.
+        ///
+        template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)>
+        BOOST_FORCEINLINE
+        static expr const make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const &a))
+        {
+            expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)};
+            return that;
+        }
+    #endif
+
+    #if 1 == BOOST_PP_ITERATION()
+        /// If \c Tag is \c boost::proto::tag::address_of and \c proto_child0 is
+        /// <tt>T&</tt>, then \c address_of_hack_type_ is <tt>T*</tt>.
+        /// Otherwise, it is some undefined type.
+        typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
+
+        /// \return The address of <tt>this->child0</tt> if \c Tag is
+        /// \c boost::proto::tag::address_of. Otherwise, this function will
+        /// fail to compile.
+        ///
+        /// \attention Proto overloads <tt>operator&</tt>, which means that
+        /// proto-ified objects cannot have their addresses taken, unless we use
+        /// the following hack to make \c &x implicitly convertible to \c X*.
+        BOOST_FORCEINLINE
+        operator address_of_hack_type_() const
+        {
+            return boost::addressof(this->child0);
+        }
+    #else
+        /// INTERNAL ONLY
+        ///
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    #endif
+
+        /// Assignment
+        ///
+        /// \param a The rhs.
+        /// \return A new \c expr\<\> node representing an assignment of \c that to \c *this.
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, expr const &>
+          , 2
+        > const
+        operator =(expr const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, expr const &>
+              , 2
+            > that = {*this, a};
+            return that;
+        }
+
+        /// Assignment
+        ///
+        /// \param a The rhs.
+        /// \return A new \c expr\<\> node representing an assignment of \c a to \c *this.
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::assign
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a) const
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator =(A &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::assign
+          , list2<expr &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator =(A const &a)
+        {
+            proto::expr<
+                proto::tag::assign
+              , list2<expr &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+    #endif
+
+        /// Subscript
+        ///
+        /// \param a The rhs.
+        /// \return A new \c expr\<\> node representing \c *this subscripted with \c a.
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr const &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a) const
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr const &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr &, typename result_of::as_child<A>::type>
+          , 2
+        > const
+        operator [](A &a)
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr &, typename result_of::as_child<A>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+
+        /// \overload
+        ///
+        template<typename A>
+        BOOST_FORCEINLINE
+        proto::expr<
+            proto::tag::subscript
+          , list2<expr &, typename result_of::as_child<A const>::type>
+          , 2
+        > const
+        operator [](A const &a)
+        {
+            proto::expr<
+                proto::tag::subscript
+              , list2<expr &, typename result_of::as_child<A const>::type>
+              , 2
+            > that = {*this, proto::as_child(a)};
+            return that;
+        }
+    #endif
+
+        /// Encodes the return type of \c expr\<\>::operator(), for use with \c boost::result_of\<\>
+        ///
+        template<typename Sig>
+        struct result
+        {
+            typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+        };
+
+    #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        /// \overload
+        ///
+        template<typename ...A>
+        BOOST_FORCEINLINE
+        typename result_of::funop<
+            expr const(A const &...)
+          , expr
+          , default_domain
+        >::type const
+        operator ()(A const &... a) const
+        {
+            return result_of::funop<
+                expr const(A const &...)
+              , expr
+              , default_domain
+            >::call(*this, a...);
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \overload
+        ///
+        template<typename ...A>
+        BOOST_FORCEINLINE
+        typename result_of::funop<
+            expr(A const &...)
+          , expr
+          , default_domain
+        >::type const
+        operator ()(A const &... a)
+        {
+            return result_of::funop<
+                expr(A const &...)
+              , expr
+              , default_domain
+            >::call(*this, a...);
+        }
+    #endif
+
+    #else // BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+        /// Function call
+        ///
+        /// \return A new \c expr\<\> node representing the function invocation of \c (*this)().
+        BOOST_FORCEINLINE
+        proto::expr<proto::tag::function, list1<expr const &>, 1> const
+        operator ()() const
+        {
+            proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+            return that;
+        }
+
+    #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \overload
+        ///
+        BOOST_FORCEINLINE
+        proto::expr<proto::tag::function, list1<expr &>, 1> const
+        operator ()()
+        {
+            proto::expr<proto::tag::function, list1<expr &>, 1> that = {*this};
+            return that;
+        }
+    #endif
+
+    #define BOOST_PP_ITERATION_PARAMS_2                                                             \
+        (3, (1, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/expr_funop.hpp>))
+    #include BOOST_PP_ITERATE()
+
+#endif
+    };
+
+#undef ARG_COUNT
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/expr_funop.hpp

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////
+// expr1.hpp
+// Contains definition of expr\<\>::operator() overloads.
+//
+//  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)
+
+#define N BOOST_PP_ITERATION()
+
+        /// \overload
+        ///
+        template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+        BOOST_FORCEINLINE
+        typename result_of::BOOST_PP_CAT(funop, N)<
+            expr const
+          , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+        >::type const
+        operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
+        {
+            return result_of::BOOST_PP_CAT(funop, N)<
+                expr const
+              , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+            >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
+        }
+
+        #ifdef BOOST_PROTO_DEFINE_TERMINAL
+        /// \overload
+        ///
+        template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+        BOOST_FORCEINLINE
+        typename result_of::BOOST_PP_CAT(funop, N)<
+            expr
+          , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+        >::type const
+        operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a))
+        {
+            return result_of::BOOST_PP_CAT(funop, N)<
+                expr
+              , default_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+            >::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
+        }
+        #endif
+
+#undef N

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/extends_funop.hpp

@@ -0,0 +1,43 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        BOOST_PROTO_EXTENDS_FUNCTION_()
+        BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY)
+        BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)
+    #else
+        #include <boost/proto/detail/preprocessed/extends_funop.hpp>
+    #endif
+
+#else
+
+    #define BOOST_PP_LOCAL_MACRO(N)                                                                 \
+        BOOST_PROTO_DEFINE_FUN_OP(1, N, ~)                                                          \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file extends_funop.hpp
+    /// Definitions for extends\<\>::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) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
+        #pragma wave option(preserve: 1)
+    #endif
+
+    BOOST_PROTO_EXTENDS_FUNCTION_()
+
+    #define BOOST_PP_LOCAL_LIMITS                                                                   \
+        (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+    #include BOOST_PP_LOCAL_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES) && !defined(BOOST_PROTO_NO_WAVE_OUTPUT)
+        #pragma wave option(output: null)
+    #endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/extends_funop_const.hpp

@@ -0,0 +1,42 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        BOOST_PROTO_EXTENDS_FUNCTION_()
+        BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)
+    #else
+        #include <boost/proto/detail/preprocessed/extends_funop_const.hpp>
+    #endif
+
+#else
+
+    #define BOOST_PP_LOCAL_MACRO(N)                                                                 \
+        BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~)                                                    \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/extends_funop_const.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file extends_funop_const.hpp
+    /// Definitions for extends\<\>::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
+
+    BOOST_PROTO_EXTENDS_FUNCTION_()
+
+    #define BOOST_PP_LOCAL_LIMITS                                                                   \
+        (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+    #include BOOST_PP_LOCAL_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/funop.hpp

@@ -0,0 +1,87 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/funop.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_AS_CHILD_TYPE(Z, N, DATA)                                                   \
+        typename proto::result_of::as_child<BOOST_PP_CAT(A, N), Domain>::type                       \
+        /**/
+
+    #define BOOST_PROTO_AS_CHILD(Z, N, DATA)                                                        \
+        proto::as_child<Domain>(BOOST_PP_CAT(a, N))                                                 \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/funop.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // funop.hpp
+    // Contains definition of funop[n]\<\> 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_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY), <boost/proto/detail/funop.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #undef BOOST_PROTO_AS_CHILD
+    #undef BOOST_PROTO_AS_CHILD_TYPE
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else
+
+    /// \brief A helper metafunction for computing the
+    /// return type of \c proto::expr\<\>::operator().
+    template<typename Expr, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A)>
+    struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION())
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))<
+                Expr &
+                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~)
+            >
+        >::type type;
+
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a)
+        )
+        {
+            type that = {
+                e
+                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~)
+            };
+            return that;
+        }
+    };
+
+    /// \brief A helper metafunction for computing the
+    /// return type of \c proto::expr\<\>::operator().
+    template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain>
+    struct funop<Expr(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain>
+      : BOOST_PP_CAT(funop, BOOST_PP_ITERATION())<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
+                BOOST_PP_ITERATION()
+              , typename remove_reference<A
+              , >::type BOOST_PP_INTERCEPT
+            )
+        >
+    {};
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/generate_by_value.hpp

@@ -0,0 +1,93 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/generate_by_value.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/generate_by_value.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file generate_by_value.hpp
+    /// Contains definition of by_value_generator_\<\> 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/detail/generate_by_value.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >
+    struct by_value_generator_<
+        proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N>
+    >
+    {
+        typedef
+            BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>
+        src_args;
+
+        typedef
+            BOOST_PP_CAT(list, N)<
+                BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT)
+            >
+        dst_args;
+
+        typedef proto::expr<Tag, src_args, N> src_type;
+        typedef proto::expr<Tag, dst_args, N> type;
+
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                BOOST_PP_ENUM_PARAMS(N, e.child)
+            };
+            return that;
+        }
+    };
+
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Arg) >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>, N>
+    >
+    {
+        typedef
+            BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, Arg)>
+        src_args;
+
+        typedef
+            BOOST_PP_CAT(list, N)<
+                BOOST_PP_ENUM_BINARY_PARAMS(N, typename uncvref<Arg, >::type BOOST_PP_INTERCEPT)
+            >
+        dst_args;
+
+        typedef proto::basic_expr<Tag, src_args, N> src_type;
+        typedef proto::basic_expr<Tag, dst_args, N> type;
+
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                BOOST_PP_ENUM_PARAMS(N, e.child)
+            };
+            return that;
+        }
+    };
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/ignore_unused.hpp

@@ -0,0 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file ignore_unused.hpp
+/// Definintion of ignore_unused, a dummy function for suppressing compiler
+/// warnings
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008
+#define BOOST_PROTO_DETAIL_IGNORE_UNUSED_HPP_EAN_03_03_2008
+
+#include <boost/config.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        BOOST_FORCEINLINE void ignore_unused(T const &)
+        {}
+    }
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/is_noncopyable.hpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file is_noncopyable.hpp
+/// Utility for detecting when types are non-copyable
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012
+#define BOOST_PROTO_DETAIL_IS_NONCOPYABLE_HPP_EAN_19_07_2012
+
+#include <boost/noncopyable.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_abstract.hpp>
+#include <boost/type_traits/is_function.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace detail
+{
+    // All classes derived from std::ios_base have these public nested types,
+    // and are non-copyable. This is an imperfect test, but it's the best we
+    // we can do.
+    template<typename T>
+    yes_type check_is_iostream(
+        typename T::failure *
+      , typename T::Init *
+      , typename T::fmtflags *
+      , typename T::iostate *
+      , typename T::openmode *
+      , typename T::seekdir *
+    );
+
+    template<typename T>
+    no_type check_is_iostream(...);
+
+    template<typename T>
+    struct is_iostream
+    {
+        static bool const value = sizeof(yes_type) == sizeof(check_is_iostream<T>(0,0,0,0,0,0));
+        typedef mpl::bool_<value> type;
+    };
+
+    /// INTERNAL ONLY
+    // This should be a customization point. And it serves the same purpose
+    // as the is_noncopyable trait in Boost.Foreach. 
+    template<typename T>
+    struct is_noncopyable
+        : mpl::or_<
+            is_function<T>
+          , is_abstract<T>
+          , is_iostream<T>
+          , is_base_of<noncopyable, T>
+        >
+    {};
+
+    template<typename T, std::size_t N>
+    struct is_noncopyable<T[N]>
+      : mpl::true_
+    {};
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/lambda_matches.hpp

@@ -0,0 +1,61 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/lambda_matches.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_DEFINE_LAMBDA_MATCHES(Z, N, DATA)                                           \
+        lambda_matches<                                                                             \
+            BOOST_PP_CAT(Expr, N)                                                                   \
+          , BOOST_PP_CAT(Grammar, N)                                                                \
+        >
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lambda_matches.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file lambda_matches.hpp
+    /// Specializations of the lambda_matches 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/lambda_matches.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEFINE_LAMBDA_MATCHES
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    template<
+        template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T
+        BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Expr)
+        BOOST_PP_ENUM_TRAILING_PARAMS(N, typename Grammar)
+    >
+    struct lambda_matches<
+        T<BOOST_PP_ENUM_PARAMS(N, Expr)>
+      , T<BOOST_PP_ENUM_PARAMS(N, Grammar)>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)
+    >
+      : BOOST_PP_CAT(and_, N)<
+            BOOST_PROTO_DEFINE_LAMBDA_MATCHES(~, 0, ~)::value,
+            BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_LAMBDA_MATCHES, ~)
+        >
+    {};
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/local.hpp

@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file local.hpp
+/// Contains macros to ease the generation of repetitious code constructs
+//
+//  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)
+
+#ifndef BOOST_PROTO_LOCAL_MACRO
+# error "local iteration target macro is not defined"
+#endif
+
+#ifndef BOOST_PROTO_LOCAL_LIMITS
+# define BOOST_PROTO_LOCAL_LIMITS (1, BOOST_PROTO_MAX_ARITY)
+#endif
+
+#ifndef BOOST_PROTO_LOCAL_typename_A
+# define BOOST_PROTO_LOCAL_typename_A BOOST_PROTO_typename_A
+#endif
+
+#ifndef BOOST_PROTO_LOCAL_A
+# define BOOST_PROTO_LOCAL_A BOOST_PROTO_A_const_ref
+#endif
+
+#ifndef BOOST_PROTO_LOCAL_A_a
+# define BOOST_PROTO_LOCAL_A_a BOOST_PROTO_A_const_ref_a
+#endif
+
+#ifndef BOOST_PROTO_LOCAL_a
+# define BOOST_PROTO_LOCAL_a BOOST_PROTO_ref_a
+#endif
+
+#define BOOST_PP_LOCAL_LIMITS BOOST_PROTO_LOCAL_LIMITS
+
+#define BOOST_PP_LOCAL_MACRO(N)       \
+  BOOST_PROTO_LOCAL_MACRO(            \
+      N                               \
+    , BOOST_PROTO_LOCAL_typename_A    \
+    , BOOST_PROTO_LOCAL_A             \
+    , BOOST_PROTO_LOCAL_A_a           \
+    , BOOST_PROTO_LOCAL_a             \
+  )                                   \
+  /**/
+
+#include BOOST_PP_LOCAL_ITERATE()
+
+#undef BOOST_PROTO_LOCAL_MACRO
+#undef BOOST_PROTO_LOCAL_LIMITS
+#undef BOOST_PROTO_LOCAL_typename_A
+#undef BOOST_PROTO_LOCAL_A
+#undef BOOST_PROTO_LOCAL_A_a
+#undef BOOST_PROTO_LOCAL_a

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/make_expr.hpp

@@ -0,0 +1,75 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/make_expr.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/make_expr.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr.hpp
+    /// Contains overloads of make_expr() free function.
+    //
+    //  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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    /// \overload
+    ///
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+        >
+    >::type const
+    make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a))
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+        >()(BOOST_PP_ENUM_PARAMS(N, a));
+    }
+
+    /// \overload
+    ///
+    template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename C)>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
+    >::type const
+    make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, const C, &c))
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, const C)
+        >()(BOOST_PP_ENUM_PARAMS(N, c));
+    }
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/make_expr_.hpp

@@ -0,0 +1,105 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/make_expr_.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/make_expr_.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_.hpp
+    /// Contains definition of make_expr_\<\> 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
+
+    template<
+        typename Tag
+      , typename Domain
+        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
+            BOOST_PROTO_MAX_ARITY
+          , typename A
+          , = void BOOST_PP_INTERCEPT
+        )
+      , typename _ = void
+    >
+    struct make_expr_
+    {};
+
+    template<typename Domain, typename A>
+    struct make_expr_<tag::terminal, Domain, A
+        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)>
+    {
+        typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A>::type a) const
+        {
+            return proto::detail::protoify<A, Domain>()(a);
+        }
+    };
+
+    template<typename A>
+    struct make_expr_<tag::terminal, deduce_domain, A
+        BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PROTO_MAX_ARITY, void BOOST_PP_INTERCEPT)>
+      : make_expr_<tag::terminal, default_domain, A>
+    {};
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                         \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+    #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)
+
+    template<typename Tag, typename Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct make_expr_<Tag, Domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+        BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void>
+    {
+        typedef
+            BOOST_PP_CAT(list, N)<
+                BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD_TYPE, (A, ~, Domain))
+            >
+        proto_args;
+
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+
+        BOOST_FORCEINLINE
+        result_type operator()(BOOST_PP_ENUM_BINARY_PARAMS(N, typename add_reference<A, >::type a)) const
+        {
+            expr_type const that = {
+                BOOST_PP_ENUM(N, BOOST_PROTO_AS_CHILD, (A, a, Domain))
+            };
+            return proto_generator()(that);
+        }
+    };
+
+    template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct make_expr_<Tag, deduce_domain BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+        BOOST_PP_ENUM_TRAILING_PARAMS(M, void BOOST_PP_INTERCEPT), void>
+      : make_expr_<
+            Tag
+          , typename BOOST_PP_CAT(deduce_domain, N)<BOOST_PP_ENUM_PARAMS(N, A)>::type
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+        >
+    {};
+
+    #undef N
+    #undef M
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/make_expr_funop.hpp

@@ -0,0 +1,67 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/make_expr_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/make_expr_funop.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_funop.hpp
+    /// Contains definition of make_expr\<\>::operator() member functions.
+    //
+    //  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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_funop.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+            >::type
+        type;
+    };
+
+    /// \overload
+    ///
+    template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+    >::type const
+    operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
+        >()(BOOST_PP_ENUM_PARAMS(N, a));
+    }
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/matches_.hpp

@@ -0,0 +1,96 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/matches_.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_MATCHES_N_FUN(Z, N, DATA)                                                   \
+        matches_<                                                                                   \
+            typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_derived_expr \
+          , typename detail::expr_traits<typename Args1::BOOST_PP_CAT(child, N)>::value_type::proto_grammar \
+          , typename Args2::BOOST_PP_CAT(child, N)::proto_grammar                                   \
+        >
+
+    #define BOOST_PROTO_DEFINE_MATCHES(Z, N, DATA)                                                  \
+        matches_<                                                                                   \
+            Expr                                                                                    \
+          , BasicExpr                                                                               \
+          , typename BOOST_PP_CAT(G, N)::proto_grammar                                              \
+        >
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/matches_.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file matches_.hpp
+    /// Definitions of matches_ specializations
+    //
+    //  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, (2, BOOST_PP_MAX(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_MAX_LOGICAL_ARITY), <boost/proto/detail/matches_.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_DEFINE_MATCHES
+    #undef BOOST_PROTO_MATCHES_N_FUN
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    #if N <= BOOST_PROTO_MAX_LOGICAL_ARITY
+
+        // handle proto::or_
+        template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)>
+        struct matches_<Expr, BasicExpr, proto::or_<BOOST_PP_ENUM_PARAMS(N, G)> >
+          : BOOST_PP_CAT(or_, N)<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, G)
+            >
+        {};
+
+        // handle proto::and_
+        template<typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)>
+        struct matches_<Expr, BasicExpr, proto::and_<BOOST_PP_ENUM_PARAMS(N, G)> >
+          : detail::BOOST_PP_CAT(and_, N)<
+                BOOST_PROTO_DEFINE_MATCHES(~, 0, ~)::value,
+                BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFINE_MATCHES, ~)
+            >
+        {};
+
+    #endif
+
+    #if N <= BOOST_PROTO_MAX_ARITY
+
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<Tag, Args2, N> >
+          : BOOST_PP_CAT(and_, N)<
+                BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value,
+                BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~)
+            >
+        {};
+
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, N>, proto::basic_expr<proto::_, Args2, N> >
+          : BOOST_PP_CAT(and_, N)<
+                BOOST_PROTO_MATCHES_N_FUN(~, 0, ~)::value,
+                BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_MATCHES_N_FUN, ~)
+            >
+        {};
+
+    #endif
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/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

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/or_n.hpp

@@ -0,0 +1,59 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/or_n.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/or_n.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file or_n.hpp
+    /// Definitions of or_N
+    //
+    //  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, (2, BOOST_PROTO_MAX_LOGICAL_ARITY, <boost/proto/detail/or_n.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    template<bool B, typename Expr, typename BasicExpr, BOOST_PP_ENUM_PARAMS(N, typename G)>
+    struct BOOST_PP_CAT(or_, N)
+    #if 2 == N
+      : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value>
+    {
+        typedef G1 which;
+    };
+    #else
+      : BOOST_PP_CAT(or_, BOOST_PP_DEC(N))<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, BOOST_PP_ENUM_SHIFTED_PARAMS(N, G)
+        >
+    {};
+    #endif
+
+    template<typename Expr, typename BasicExpr BOOST_PP_ENUM_TRAILING_PARAMS(N, typename G)>
+    struct BOOST_PP_CAT(or_, N)<true, Expr, BasicExpr, BOOST_PP_ENUM_PARAMS(N, G)>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/poly_function.hpp

@@ -0,0 +1,234 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file poly_function.hpp
+/// A wrapper that makes a tr1-style function object that handles const
+/// and non-const refs and reference_wrapper arguments, too, and forwards
+/// the arguments on to the specified implementation.
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02
+#define BOOST_PROTO_DETAIL_POLY_FUNCTION_EAN_2008_05_02
+
+#include <boost/ref.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/detail/is_noncopyable.hpp>
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4181) // const applied to reference type
+#endif
+
+namespace boost { namespace proto { namespace detail
+{
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct normalize_arg
+    {
+        typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type;
+        typedef T &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<T const>
+    {
+        typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type;
+        typedef T const &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<T &>
+    {
+        typedef typename mpl::if_c<is_noncopyable<T>::value, T &, T>::type type;
+        typedef T &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<T const &>
+    {
+        typedef typename mpl::if_c<is_noncopyable<T>::value, T const &, T>::type type;
+        typedef T const &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> >
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> const>
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> &>
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+
+    template<typename T>
+    struct normalize_arg<boost::reference_wrapper<T> const &>
+    {
+        typedef T &type;
+        typedef T &reference;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T>
+    struct arg
+    {
+        typedef T const &type;
+
+        arg(type t)
+          : value(t)
+        {}
+
+        operator type() const
+        {
+            return this->value;
+        }
+
+        type operator()() const
+        {
+            return this->value;
+        }
+
+        BOOST_DELETED_FUNCTION(arg &operator =(arg const &))
+    private:
+        type value;
+    };
+
+    template<typename T>
+    struct arg<T &>
+    {
+        typedef T &type;
+
+        arg(type t)
+          : value(t)
+        {}
+
+        operator type() const
+        {
+            return this->value;
+        }
+
+        type operator()() const
+        {
+            return this->value;
+        }
+
+        BOOST_DELETED_FUNCTION(arg &operator =(arg const &))
+    private:
+        type value;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename T, typename Void = void>
+    struct is_poly_function
+      : mpl::false_
+    {};
+
+    template<typename T>
+    struct is_poly_function<T, typename T::is_poly_function_base_>
+      : mpl::true_
+    {};
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    #define BOOST_PROTO_POLY_FUNCTION()                                                             \
+        typedef void is_poly_function_base_;                                                        \
+        /**/
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    struct poly_function_base
+    {
+        /// INTERNAL ONLY
+        BOOST_PROTO_POLY_FUNCTION()
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename Derived, typename NullaryResult = void>
+    struct poly_function
+      : poly_function_base
+    {
+        template<typename Sig>
+        struct result;
+
+        template<typename This>
+        struct result<This()>
+          : Derived::template impl<>
+        {
+            typedef typename result::result_type type;
+        };
+
+        NullaryResult operator()() const
+        {
+            result<Derived const()> impl;
+            return impl();
+        }
+
+        #include <boost/proto/detail/poly_function_funop.hpp>
+    };
+
+    template<typename T>
+    struct wrap_t;
+
+    typedef char poly_function_t;
+    typedef char (&mono_function_t)[2];
+    typedef char (&unknown_function_t)[3];
+
+    template<typename T> poly_function_t test_poly_function(T *, wrap_t<typename T::is_poly_function_base_> * = 0);
+    template<typename T> mono_function_t test_poly_function(T *, wrap_t<typename T::result_type> * = 0);
+    template<typename T> unknown_function_t test_poly_function(T *, ...);
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename Fun, typename Sig, typename Switch = mpl::size_t<sizeof(test_poly_function<Fun>(0,0))> >
+    struct poly_function_traits
+    {
+        typedef typename Fun::template result<Sig>::type result_type;
+        typedef Fun function_type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename Fun, typename Sig>
+    struct poly_function_traits<Fun, Sig, mpl::size_t<sizeof(mono_function_t)> >
+    {
+        typedef typename Fun::result_type result_type;
+        typedef Fun function_type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PolyFunSig, bool IsPolyFunction>
+    struct as_mono_function_impl;
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PolyFunSig>
+    struct as_mono_function;
+
+    #include <boost/proto/detail/poly_function_traits.hpp>
+
+}}} // namespace boost::proto::detail
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#endif
+

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/poly_function_funop.hpp

@@ -0,0 +1,74 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/poly_function_funop.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_NORMALIZE_ARG(Z, N, DATA)                                                   \
+        static_cast<typename normalize_arg<BOOST_PP_CAT(A, N) const &>                              \
+            ::reference>(BOOST_PP_CAT(a, N))                                                        \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/poly_function_funop.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // poly_function_funop.hpp
+    // Contains overloads of poly_function\<\>::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/poly_function_funop.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_NORMALIZE_ARG
+
+#else
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
+      : Derived::template impl<
+            BOOST_PP_ENUM_BINARY_PARAMS(
+                N
+              , typename normalize_arg<A
+              , >::type BOOST_PP_INTERCEPT
+            )
+        >
+    {
+        typedef typename result::result_type type;
+    };
+
+    template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+    typename result<
+        Derived const(
+            BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT)
+        )
+    >::type
+    operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
+    {
+        result<
+            Derived const(
+                BOOST_PP_ENUM_BINARY_PARAMS(N, A, const & BOOST_PP_INTERCEPT)
+            )
+        > impl;
+
+        return impl(BOOST_PP_ENUM(N, BOOST_PROTO_NORMALIZE_ARG, ~));
+    }
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/poly_function_traits.hpp

@@ -0,0 +1,65 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/poly_function_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/poly_function_traits.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // poly_function_traits.hpp
+    // Contains specializations of poly_function_traits and as_mono_function
+    //
+    //  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/poly_function_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 PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct poly_function_traits<PolyFun, PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), true>
+    {
+        typedef typename PolyFun::template impl<BOOST_PP_ENUM_PARAMS(N, const A)> type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), false>
+    {
+        typedef PolyFun type;
+    };
+
+    ////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PolyFun BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+    struct as_mono_function<PolyFun(BOOST_PP_ENUM_PARAMS(N, A))>
+      : as_mono_function_impl<PolyFun(BOOST_PP_ENUM_PARAMS(N, A)), is_poly_function<PolyFun>::value>
+    {};
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/and_n.hpp

@@ -0,0 +1,310 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file and_n.hpp
+    /// Definitions of and_N, and_impl
+    //
+    //  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<bool B, typename P0>
+    struct and_2
+      : mpl::bool_<P0::value>
+    {};
+    template<typename P0>
+    struct and_2<false, P0>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1;
+            typedef typename Gimpl1::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d);
+                return Gimpl1()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1>
+    struct and_3
+      : and_2<
+            P0::value ,
+            P1
+        >
+    {};
+    template<typename P0 , typename P1>
+    struct and_3<false, P0 , P1>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2;
+            typedef typename Gimpl2::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d);
+                return Gimpl2()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2>
+    struct and_4
+      : and_3<
+            P0::value ,
+            P1 , P2
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2>
+    struct and_4<false, P0 , P1 , P2>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3;
+            typedef typename Gimpl3::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d);
+                return Gimpl3()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3>
+    struct and_5
+      : and_4<
+            P0::value ,
+            P1 , P2 , P3
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3>
+    struct and_5<false, P0 , P1 , P2 , P3>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4;
+            typedef typename Gimpl4::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d);
+                return Gimpl4()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
+    struct and_6
+      : and_5<
+            P0::value ,
+            P1 , P2 , P3 , P4
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4>
+    struct and_6<false, P0 , P1 , P2 , P3 , P4>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5;
+            typedef typename Gimpl5::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d);
+                return Gimpl5()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
+    struct and_7
+      : and_6<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5>
+    struct and_7<false, P0 , P1 , P2 , P3 , P4 , P5>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6;
+            typedef typename Gimpl6::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d);
+                return Gimpl6()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
+    struct and_8
+      : and_7<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6>
+    struct and_8<false, P0 , P1 , P2 , P3 , P4 , P5 , P6>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7;
+            typedef typename Gimpl7::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d);
+                return Gimpl7()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+    struct and_9
+      : and_8<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6 , P7
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+    struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
+            typedef typename Gimpl8::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
+                return Gimpl8()(e,s,d);
+            }
+        };
+    
+    
+    
+    template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+    struct and_10
+      : and_9<
+            P0::value ,
+            P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
+        >
+    {};
+    template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+    struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
+      : mpl::false_
+    {};
+        template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
+        struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
+          : proto::transform_impl<Expr, State, Data>
+        {
+            typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
+            typedef typename Gimpl9::result_type result_type;
+            result_type operator()(
+                typename _and_impl::expr_param e
+              , typename _and_impl::state_param s
+              , typename _and_impl::data_param d
+            ) const
+            {
+                
+                
+                
+                
+                Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
+                return Gimpl9()(e,s,d);
+            }
+        };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/args.hpp

@@ -0,0 +1,162 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file args.hpp
+    /// Contains definition of \c term\<\>, \c list1\<\>, \c list2\<\>, ...
+    /// class templates.
+    //
+    //  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 Arg0 >
+    struct term
+    {
+        static const long arity = 0;
+        typedef Arg0 child0;
+        typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg0 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 >
+    struct list1
+    {
+        static const long arity = 1;
+        typedef Arg0 child0;
+        typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg0 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 >
+    struct list2
+    {
+        static const long arity = 2;
+        typedef Arg0 child0; typedef Arg1 child1;
+        typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg1 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 >
+    struct list3
+    {
+        static const long arity = 3;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2;
+        typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg2 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct list4
+    {
+        static const long arity = 4;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3;
+        typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg3 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct list5
+    {
+        static const long arity = 5;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4;
+        typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg4 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct list6
+    {
+        static const long arity = 6;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5;
+        typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg5 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct list7
+    {
+        static const long arity = 7;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6;
+        typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg6 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct list8
+    {
+        static const long arity = 8;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7;
+        typedef mpl::void_ child8; typedef mpl::void_ child9;
+        
+        
+        typedef Arg7 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct list9
+    {
+        static const long arity = 9;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8;
+        typedef mpl::void_ child9;
+        
+        
+        typedef Arg8 back_;
+    };
+    
+    
+    
+    
+    template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct list10
+    {
+        static const long arity = 10;
+        typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9;
+        
+        
+        
+        typedef Arg9 back_;
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/basic_expr.hpp

@@ -0,0 +1,809 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file basic_expr.hpp
+    /// Contains definition of basic_expr\<\> 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 Tag, typename Arg0>
+    struct basic_expr<Tag, term<Arg0>, 0>
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 0;
+        typedef mpl::long_<0 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef term<Arg0> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+        
+        
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0)
+        {
+            return detail::make_terminal(a0, static_cast<basic_expr *>(0), static_cast<proto_args *>(0));
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0>
+    struct basic_expr<Tag, list1<Arg0>, 1 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 1;
+        typedef mpl::long_<1 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list1<Arg0> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0;
+        typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0)
+        {
+            basic_expr that = {a0};
+            return that;
+        }
+        
+        
+        
+        typedef typename detail::address_of_hack<Tag, proto_child0>::type address_of_hack_type_;
+        
+        
+        
+        
+        
+        
+        
+        BOOST_FORCEINLINE
+        operator address_of_hack_type_() const
+        {
+            return boost::addressof(this->child0);
+        }
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1>
+    struct basic_expr<Tag, list2<Arg0 , Arg1>, 2 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 2;
+        typedef mpl::long_<2 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list2<Arg0 , Arg1> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
+        typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1)
+        {
+            basic_expr that = {a0 , a1};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2>
+    struct basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 3;
+        typedef mpl::long_<3 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list3<Arg0 , Arg1 , Arg2> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
+        typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2)
+        {
+            basic_expr that = {a0 , a1 , a2};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3>
+    struct basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 4;
+        typedef mpl::long_<4 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list4<Arg0 , Arg1 , Arg2 , Arg3> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
+        typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4>
+    struct basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 5;
+        typedef mpl::long_<5 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
+        typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+    struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 6;
+        typedef mpl::long_<6 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+        typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+    struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 7;
+        typedef mpl::long_<7 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+        typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+    struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 8;
+        typedef mpl::long_<8 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+        typedef void proto_child8; typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+        BOOST_FORCEINLINE
+        static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+    struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 9;
+        typedef mpl::long_<9 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+        typedef void proto_child9;
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+        BOOST_FORCEINLINE
+        static basic_expr const make(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)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+    struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+    {
+        typedef Tag proto_tag;
+        static const long proto_arity_c = 10;
+        typedef mpl::long_<10 > proto_arity;
+        typedef basic_expr proto_base_expr;
+        typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+        typedef basic_expr proto_grammar;
+        typedef basic_default_domain proto_domain;
+        typedef default_generator proto_generator;
+        typedef proto::tag::proto_expr<Tag, proto_domain> fusion_tag;
+        typedef basic_expr proto_derived_expr;
+        typedef void proto_is_expr_; 
+        typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+        
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr const &proto_base() const
+        {
+            return *this;
+        }
+        
+        
+        BOOST_FORCEINLINE
+        basic_expr &proto_base()
+        {
+            return *this;
+        }
+        
+        
+        
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+        BOOST_FORCEINLINE
+        static basic_expr const make(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)
+        {
+            basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+            return that;
+        }
+        
+        
+        typedef detail::not_a_valid_type address_of_hack_type_;
+    };

externals/vcpkg/packages/boost-proto_x64-windows/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;
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/deduce_domain_n.hpp

@@ -0,0 +1,119 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // deduce_domain_n.hpp
+    // Definitions of common_domain[n] and deduce_domain[n] class templates.
+    //
+    //  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 , typename A1 , typename A2>
+    struct common_domain3
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3;
+        typedef common3 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2>
+    struct deduce_domain3
+      : common_domain3<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    struct common_domain4
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4;
+        typedef common4 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3>
+    struct deduce_domain4
+      : common_domain4<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct common_domain5
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5;
+        typedef common5 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4>
+    struct deduce_domain5
+      : common_domain5<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct common_domain6
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6;
+        typedef common6 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5>
+    struct deduce_domain6
+      : common_domain6<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct common_domain7
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7;
+        typedef common7 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6>
+    struct deduce_domain7
+      : common_domain7<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct common_domain8
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8;
+        typedef common8 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7>
+    struct deduce_domain8
+      : common_domain8<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct common_domain9
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9;
+        typedef common9 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8>
+    struct deduce_domain9
+      : common_domain9<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type
+        >
+    {};
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct common_domain10
+    {
+        typedef A0 common1;
+        typedef typename common_domain2<common1, A1>::type common2; typedef typename common_domain2<common2, A2>::type common3; typedef typename common_domain2<common3, A3>::type common4; typedef typename common_domain2<common4, A4>::type common5; typedef typename common_domain2<common5, A5>::type common6; typedef typename common_domain2<common6, A6>::type common7; typedef typename common_domain2<common7, A7>::type common8; typedef typename common_domain2<common8, A8>::type common9; typedef typename common_domain2<common9, A9>::type common10;
+        typedef common10 type;
+        BOOST_PROTO_ASSERT_VALID_DOMAIN(type);
+    };
+    template<typename E0 , typename E1 , typename E2 , typename E3 , typename E4 , typename E5 , typename E6 , typename E7 , typename E8 , typename E9>
+    struct deduce_domain10
+      : common_domain10<
+            typename domain_of<E0 >::type , typename domain_of<E1 >::type , typename domain_of<E2 >::type , typename domain_of<E3 >::type , typename domain_of<E4 >::type , typename domain_of<E5 >::type , typename domain_of<E6 >::type , typename domain_of<E7 >::type , typename domain_of<E8 >::type , typename domain_of<E9 >::type
+        >
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/deep_copy.hpp

@@ -0,0 +1,237 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file deep_copy.hpp
+    /// Replace all nodes stored by reference by nodes stored by value.
+    //
+    //  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>
+    struct deep_copy_impl<Expr, 1>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list1<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 2>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list2<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 3>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list3<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 4>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list4<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 5>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list5<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 6>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list6<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 7>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list7<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 8>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list8<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 9>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list9<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Expr>
+    struct deep_copy_impl<Expr, 10>
+    {
+        typedef
+            typename base_expr<
+                typename Expr::proto_domain
+              , typename Expr::proto_tag
+              , list10<
+                    typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type
+                >
+            >::type
+        expr_type;
+        typedef typename Expr::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        template<typename Expr2, typename S, typename D>
+        result_type operator()(Expr2 const &e, S const &, D const &) const
+        {
+            expr_type const that = {
+                proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9)
+            };
+            return proto_generator()(that);
+        }
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/extends_funop.hpp

@@ -0,0 +1,18 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file extends_funop.hpp
+    /// Definitions for extends\<\>::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 Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
+        BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); } BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr , proto_domain >::type ) >::type const operator ()() { typedef boost::proto::result_of::funop0< proto_derived_expr , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) ) ); }
+        template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); } template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) { typedef boost::proto::result_of::funop1< proto_derived_expr , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 ) ); }
+        template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); }
+        template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { typedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , 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 typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const 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 { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , 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> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const 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) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , 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 typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const 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 { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , 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> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const 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) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/extends_funop_const.hpp

@@ -0,0 +1,18 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file extends_funop_const.hpp
+    /// Definitions for extends\<\>::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 Sig> struct result { typedef typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop< Sig , proto_derived_expr , proto_domain >::type ) >::type const type; };
+        BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop0< proto_derived_expr const , proto_domain >::type ) >::type const operator ()() const { typedef boost::proto::result_of::funop0< proto_derived_expr const , proto_domain > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) ) ); }
+        template<typename A0> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 >::type ) >::type const operator ()(A0 const &a0) const { typedef boost::proto::result_of::funop1< proto_derived_expr const , proto_domain , const A0 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 ) ); }
+        template<typename A0 , typename A1> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); }
+        template<typename A0 , typename A1 , typename A2> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+        template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> BOOST_FORCEINLINE typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , 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 typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const 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 { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , 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 typename BOOST_PROTO_RESULT_OF< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const 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 { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/funop.hpp

@@ -0,0 +1,367 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // funop.hpp
+    // Contains definition of funop[n]\<\> 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 Domain >
+    struct funop0
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list1<
+                Expr &
+                
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            
+        )
+        {
+            type that = {
+                e
+                
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename This, typename Domain>
+    struct funop<Expr(), This, Domain>
+      : funop0<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0>
+    struct funop1
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list2<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0, typename This, typename Domain>
+    struct funop<Expr(A0), This, Domain>
+      : funop1<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1>
+    struct funop2
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list3<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1, typename This, typename Domain>
+    struct funop<Expr(A0 , A1), This, Domain>
+      : funop2<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2>
+    struct funop3
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list4<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2), This, Domain>
+      : funop3<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
+    struct funop4
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list5<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3), This, Domain>
+      : funop4<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct funop5
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list6<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain>
+      : funop5<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct funop6
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list7<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain>
+      : funop6<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct funop7
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list8<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain>
+      : funop7<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct funop8
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list9<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain>
+      : funop8<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
+        >
+    {};
+    
+    
+    template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct funop9
+    {
+        typedef typename proto::base_expr<
+            Domain
+          , tag::function
+          , list10<
+                Expr &
+                , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type
+            >
+        >::type type;
+        BOOST_FORCEINLINE
+        static type const call(
+            Expr &e
+            , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8
+        )
+        {
+            type that = {
+                e
+                , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8)
+            };
+            return that;
+        }
+    };
+    
+    
+    template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain>
+    struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain>
+      : funop9<
+            typename detail::same_cv<Expr, This>::type
+          , Domain
+            , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
+        >
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/generate_by_value.hpp

@@ -0,0 +1,487 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file generate_by_value.hpp
+    /// Contains definition of by_value_generator_\<\> 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 Tag , typename Arg0 >
+    struct by_value_generator_<
+        proto::expr<Tag, list1<Arg0>, 1>
+    >
+    {
+        typedef
+            list1<Arg0>
+        src_args;
+        typedef
+            list1<
+                typename uncvref<Arg0 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 1> src_type;
+        typedef proto::expr<Tag, dst_args, 1> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list1<Arg0>, 1>
+    >
+    {
+        typedef
+            list1<Arg0>
+        src_args;
+        typedef
+            list1<
+                typename uncvref<Arg0 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 1> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 1> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 >
+    struct by_value_generator_<
+        proto::expr<Tag, list2<Arg0 , Arg1>, 2>
+    >
+    {
+        typedef
+            list2<Arg0 , Arg1>
+        src_args;
+        typedef
+            list2<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 2> src_type;
+        typedef proto::expr<Tag, dst_args, 2> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list2<Arg0 , Arg1>, 2>
+    >
+    {
+        typedef
+            list2<Arg0 , Arg1>
+        src_args;
+        typedef
+            list2<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 2> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 2> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
+    struct by_value_generator_<
+        proto::expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
+    >
+    {
+        typedef
+            list3<Arg0 , Arg1 , Arg2>
+        src_args;
+        typedef
+            list3<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 3> src_type;
+        typedef proto::expr<Tag, dst_args, 3> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list3<Arg0 , Arg1 , Arg2>, 3>
+    >
+    {
+        typedef
+            list3<Arg0 , Arg1 , Arg2>
+        src_args;
+        typedef
+            list3<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 3> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 3> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct by_value_generator_<
+        proto::expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
+    >
+    {
+        typedef
+            list4<Arg0 , Arg1 , Arg2 , Arg3>
+        src_args;
+        typedef
+            list4<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 4> src_type;
+        typedef proto::expr<Tag, dst_args, 4> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list4<Arg0 , Arg1 , Arg2 , Arg3>, 4>
+    >
+    {
+        typedef
+            list4<Arg0 , Arg1 , Arg2 , Arg3>
+        src_args;
+        typedef
+            list4<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 4> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 4> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct by_value_generator_<
+        proto::expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
+    >
+    {
+        typedef
+            list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
+        src_args;
+        typedef
+            list5<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 5> src_type;
+        typedef proto::expr<Tag, dst_args, 5> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>, 5>
+    >
+    {
+        typedef
+            list5<Arg0 , Arg1 , Arg2 , Arg3 , Arg4>
+        src_args;
+        typedef
+            list5<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 5> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 5> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct by_value_generator_<
+        proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+    >
+    {
+        typedef
+            list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+        src_args;
+        typedef
+            list6<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 6> src_type;
+        typedef proto::expr<Tag, dst_args, 6> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+    >
+    {
+        typedef
+            list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+        src_args;
+        typedef
+            list6<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 6> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 6> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct by_value_generator_<
+        proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+    >
+    {
+        typedef
+            list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+        src_args;
+        typedef
+            list7<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 7> src_type;
+        typedef proto::expr<Tag, dst_args, 7> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+    >
+    {
+        typedef
+            list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+        src_args;
+        typedef
+            list7<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 7> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 7> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct by_value_generator_<
+        proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+    >
+    {
+        typedef
+            list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+        src_args;
+        typedef
+            list8<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 8> src_type;
+        typedef proto::expr<Tag, dst_args, 8> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+    >
+    {
+        typedef
+            list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+        src_args;
+        typedef
+            list8<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 8> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 8> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct by_value_generator_<
+        proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+    >
+    {
+        typedef
+            list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+        src_args;
+        typedef
+            list9<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 9> src_type;
+        typedef proto::expr<Tag, dst_args, 9> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+    >
+    {
+        typedef
+            list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+        src_args;
+        typedef
+            list9<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 9> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 9> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct by_value_generator_<
+        proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+    >
+    {
+        typedef
+            list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+        src_args;
+        typedef
+            list10<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+            >
+        dst_args;
+        typedef proto::expr<Tag, src_args, 10> src_type;
+        typedef proto::expr<Tag, dst_args, 10> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+            };
+            return that;
+        }
+    };
+    template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+    struct by_value_generator_<
+        proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+    >
+    {
+        typedef
+            list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+        src_args;
+        typedef
+            list10<
+                typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+            >
+        dst_args;
+        typedef proto::basic_expr<Tag, src_args, 10> src_type;
+        typedef proto::basic_expr<Tag, dst_args, 10> type;
+        BOOST_FORCEINLINE
+        static type const call(src_type const &e)
+        {
+            type that = {
+                e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+            };
+            return that;
+        }
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/lambda_matches.hpp

@@ -0,0 +1,142 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file lambda_matches.hpp
+    /// Specializations of the lambda_matches 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<
+        template<typename , typename> class T
+        , typename Expr0 , typename Expr1
+        , typename Grammar0 , typename Grammar1
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1>
+      , T<Grammar0 , Grammar1>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
+    >
+      : and_2<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 >
+        >
+    {};
+    template<
+        template<typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2
+        , typename Grammar0 , typename Grammar1 , typename Grammar2
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2>
+      , T<Grammar0 , Grammar1 , Grammar2>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
+    >
+      : and_3<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
+    >
+      : and_4<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
+    >
+      : and_5<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
+    >
+      : and_6<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
+    >
+      : and_7<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
+    >
+      : and_8<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
+    >
+      : and_9<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 >
+        >
+    {};
+    template<
+        template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+        , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9
+        , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9
+    >
+    struct lambda_matches<
+        T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9>
+      , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9>
+        BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
+    >
+      : and_10<
+            lambda_matches< Expr0 , Grammar0 >::value,
+            lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 >
+        >
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/make_expr.hpp

@@ -0,0 +1,331 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr.hpp
+    /// Contains overloads of make_expr() free function.
+    //
+    //  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 Tag , typename A0 , typename A1>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1
+        >()(a0 , a1);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1
+        >()(c0 , c1);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2
+        >()(a0 , a1 , a2);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2
+        >()(c0 , c1 , c2);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3
+        >()(a0 , a1 , a2 , a3);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3
+        >()(c0 , c1 , c2 , c3);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >()(a0 , a1 , a2 , a3 , a4);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4
+        >()(c0 , c1 , c2 , c3 , c4);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >()(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+        >()(c0 , c1 , c2 , c3 , c4 , c5);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8);
+    }
+    
+    
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    BOOST_FORCEINLINE
+    typename lazy_disable_if<
+        is_domain<A0>
+      , result_of::make_expr<
+            Tag
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >
+    >::type const
+    make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , deduce_domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+    
+    
+    template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+    >::type const
+    make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9)
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+        >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9);
+    }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/make_expr_.hpp

@@ -0,0 +1,331 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_.hpp
+    /// Contains definition of make_expr_\<\> 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 Tag
+      , typename Domain
+        , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
+      , typename _ = void
+    >
+    struct make_expr_
+    {};
+    template<typename Domain, typename A>
+    struct make_expr_<tag::terminal, Domain, A
+        , void , void , void , void , void , void , void , void , void , void>
+    {
+        typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A>::type a) const
+        {
+            return proto::detail::protoify<A, Domain>()(a);
+        }
+    };
+    template<typename A>
+    struct make_expr_<tag::terminal, deduce_domain, A
+        , void , void , void , void , void , void , void , void , void , void>
+      : make_expr_<tag::terminal, default_domain, A>
+    {};
+    template<typename Tag, typename Domain , typename A0>
+    struct make_expr_<Tag, Domain , A0
+        , void , void , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list1<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0>
+    struct make_expr_<Tag, deduce_domain , A0
+        , void , void , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain1<A0>::type
+            , A0
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1>
+    struct make_expr_<Tag, Domain , A0 , A1
+        , void , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list2<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1>
+    struct make_expr_<Tag, deduce_domain , A0 , A1
+        , void , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain2<A0 , A1>::type
+            , A0 , A1
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2
+        , void , void , void , void , void , void , void, void>
+    {
+        typedef
+            list3<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2
+        , void , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain3<A0 , A1 , A2>::type
+            , A0 , A1 , A2
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3
+        , void , void , void , void , void , void, void>
+    {
+        typedef
+            list4<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3
+        , void , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain4<A0 , A1 , A2 , A3>::type
+            , A0 , A1 , A2 , A3
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4
+        , void , void , void , void , void, void>
+    {
+        typedef
+            list5<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4
+        , void , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type
+            , A0 , A1 , A2 , A3 , A4
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5
+        , void , void , void , void, void>
+    {
+        typedef
+            list6<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5
+        , void , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type
+            , A0 , A1 , A2 , A3 , A4 , A5
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        , void , void , void, void>
+    {
+        typedef
+            list7<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        , void , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        , void , void, void>
+    {
+        typedef
+            list8<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        , void , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        , void, void>
+    {
+        typedef
+            list9<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        , void, void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+        >
+    {};
+    template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        , void>
+    {
+        typedef
+            list10<
+                typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+        BOOST_FORCEINLINE
+        result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const
+        {
+            expr_type const that = {
+                boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        , void>
+      : make_expr_<
+            Tag
+          , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
+            , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+        >
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/make_expr_funop.hpp

@@ -0,0 +1,259 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_funop.hpp
+    /// Contains definition of make_expr\<\>::operator() member functions.
+    //
+    //  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 This , typename A0 , typename A1>
+    struct result<This(A0 , A1)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1
+        >()(a0 , a1);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2>
+    struct result<This(A0 , A1 , A2)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2
+        >()(a0 , a1 , a2);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
+    struct result<This(A0 , A1 , A2 , A3)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3
+        >()(a0 , a1 , a2 , a3);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct result<This(A0 , A1 , A2 , A3 , A4)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4
+        >()(a0 , a1 , a2 , a3 , a4);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+        >()(a0 , a1 , a2 , a3 , a4 , a5);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+    {
+        typedef
+            typename result_of::make_expr<
+                Tag
+              , Domain
+                , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+            >::type
+        type;
+    };
+    
+    
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    BOOST_FORCEINLINE
+    typename result_of::make_expr<
+        Tag
+      , Domain
+        , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+    >::type const
+    operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) const
+    {
+        return proto::detail::make_expr_<
+            Tag
+          , Domain
+            , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+        >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/matches_.hpp

@@ -0,0 +1,277 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file matches_.hpp
+    /// Definitions of matches_ specializations
+    //
+    //  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 BasicExpr , typename G0 , typename G1>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1> >
+          : or_2<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1> >
+          : detail::and_2<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<Tag, Args2, 2> >
+          : and_2<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 2>, proto::basic_expr<proto::_, Args2, 2> >
+          : and_2<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2> >
+          : or_3<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2> >
+          : detail::and_3<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<Tag, Args2, 3> >
+          : and_3<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 3>, proto::basic_expr<proto::_, Args2, 3> >
+          : and_3<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3> >
+          : or_4<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3> >
+          : detail::and_4<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<Tag, Args2, 4> >
+          : and_4<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 4>, proto::basic_expr<proto::_, Args2, 4> >
+          : and_4<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4> >
+          : or_5<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4> >
+          : detail::and_5<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<Tag, Args2, 5> >
+          : and_5<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 5>, proto::basic_expr<proto::_, Args2, 5> >
+          : and_5<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5> >
+          : or_6<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5> >
+          : detail::and_6<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> >
+          : and_6<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> >
+          : and_6<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
+          : or_7<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
+          : detail::and_7<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> >
+          : and_7<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> >
+          : and_7<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
+          : or_8<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
+          : detail::and_8<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> >
+          : and_8<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> >
+          : and_8<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+          : or_9<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+          : detail::and_9<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> >
+          : and_9<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> >
+          : and_9<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+        struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+          : or_10<
+                matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+                Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+            >
+        {};
+        
+        template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+        struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+          : detail::and_10<
+                matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+                matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> >
+          : and_10<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+            >
+        {};
+        template<typename Expr, typename Tag, typename Args1, typename Args2>
+        struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> >
+          : and_10<
+                matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+                matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+            >
+        {};

externals/vcpkg/packages/boost-proto_x64-windows/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);
+    }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/or_n.hpp

@@ -0,0 +1,123 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file or_n.hpp
+    /// Definitions of or_N
+    //
+    //  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<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1>
+    struct or_2
+      : mpl::bool_<matches_<Expr, BasicExpr, typename G1::proto_grammar>::value>
+    {
+        typedef G1 which;
+    };
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1>
+    struct or_2<true, Expr, BasicExpr, G0 , G1>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2>
+    struct or_3
+      : or_2<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2>
+    struct or_3<true, Expr, BasicExpr, G0 , G1 , G2>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3>
+    struct or_4
+      : or_3<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3>
+    struct or_4<true, Expr, BasicExpr, G0 , G1 , G2 , G3>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+    struct or_5
+      : or_4<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4>
+    struct or_5<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+    struct or_6
+      : or_5<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5>
+    struct or_6<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+    struct or_7
+      : or_6<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
+    struct or_7<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+    struct or_8
+      : or_7<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
+    struct or_8<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+    struct or_9
+      : or_8<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+    struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };
+    template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct or_10
+      : or_9<
+            matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+          , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+        >
+    {};
+    template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+    struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>
+      : mpl::true_
+    {
+        typedef G0 which;
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/poly_function_funop.hpp

@@ -0,0 +1,237 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // poly_function_funop.hpp
+    // Contains overloads of poly_function\<\>::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 This , typename A0>
+    struct result<This(A0)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0>
+    typename result<
+        Derived const(
+            A0 const &
+        )
+    >::type
+    operator ()(A0 const &a0) const
+    {
+        result<
+            Derived const(
+                A0 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0));
+    }
+    template<typename This , typename A0 , typename A1>
+    struct result<This(A0 , A1)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1>
+    typename result<
+        Derived const(
+            A0 const & , A1 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2>
+    struct result<This(A0 , A1 , A2)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3>
+    struct result<This(A0 , A1 , A2 , A3)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct result<This(A0 , A1 , A2 , A3 , A4)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
+        )
+    >::type
+    operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
+        )
+    >::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
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
+        )
+    >::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
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8));
+    }
+    template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : Derived::template impl<
+            typename normalize_arg<A0 >::type , typename normalize_arg<A1 >::type , typename normalize_arg<A2 >::type , typename normalize_arg<A3 >::type , typename normalize_arg<A4 >::type , typename normalize_arg<A5 >::type , typename normalize_arg<A6 >::type , typename normalize_arg<A7 >::type , typename normalize_arg<A8 >::type , typename normalize_arg<A9 >::type
+        >
+    {
+        typedef typename result::result_type type;
+    };
+    template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    typename result<
+        Derived const(
+            A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
+        )
+    >::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
+    {
+        result<
+            Derived const(
+                A0 const & , A1 const & , A2 const & , A3 const & , A4 const & , A5 const & , A6 const & , A7 const & , A8 const & , A9 const &
+            )
+        > impl;
+        return impl(static_cast<typename normalize_arg<A0 const &> ::reference>(a0) , static_cast<typename normalize_arg<A1 const &> ::reference>(a1) , static_cast<typename normalize_arg<A2 const &> ::reference>(a2) , static_cast<typename normalize_arg<A3 const &> ::reference>(a3) , static_cast<typename normalize_arg<A4 const &> ::reference>(a4) , static_cast<typename normalize_arg<A5 const &> ::reference>(a5) , static_cast<typename normalize_arg<A6 const &> ::reference>(a6) , static_cast<typename normalize_arg<A7 const &> ::reference>(a7) , static_cast<typename normalize_arg<A8 const &> ::reference>(a8) , static_cast<typename normalize_arg<A9 const &> ::reference>(a9));
+    }

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/poly_function_traits.hpp

@@ -0,0 +1,247 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // poly_function_traits.hpp
+    // Contains specializations of poly_function_traits and as_mono_function
+    //
+    //  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 PolyFun , typename A0>
+    struct poly_function_traits<PolyFun, PolyFun(A0), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0>
+    struct as_mono_function_impl<PolyFun(A0), true>
+    {
+        typedef typename PolyFun::template impl<const A0> type;
+    };
+    
+    template<typename PolyFun , typename A0>
+    struct as_mono_function_impl<PolyFun(A0), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0>
+    struct as_mono_function<PolyFun(A0)>
+      : as_mono_function_impl<PolyFun(A0), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function_impl<PolyFun(A0 , A1), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function_impl<PolyFun(A0 , A1), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1>
+    struct as_mono_function<PolyFun(A0 , A1)>
+      : as_mono_function_impl<PolyFun(A0 , A1), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2>
+    struct as_mono_function<PolyFun(A0 , A1 , A2)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), is_poly_function<PolyFun>::value>
+    {};
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct poly_function_traits<PolyFun, PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), mpl::size_t<sizeof(poly_function_t)> >
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> function_type;
+        typedef typename function_type::result_type result_type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), true>
+    {
+        typedef typename PolyFun::template impl<const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9> type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), false>
+    {
+        typedef PolyFun type;
+    };
+    
+    template<typename PolyFun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+    struct as_mono_function<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+      : as_mono_function_impl<PolyFun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9), is_poly_function<PolyFun>::value>
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/template_arity_helper.hpp

@@ -0,0 +1,67 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    // template_arity_helper.hpp
+    // Overloads of template_arity_helper, used by the template_arity\<\> 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<
+        template<typename P0> class F
+      , typename T0
+    >
+    sized_type<2>::type
+    template_arity_helper(F<T0> **, mpl::int_<1> *);
+    template<
+        template<typename P0 , typename P1> class F
+      , typename T0 , typename T1
+    >
+    sized_type<3>::type
+    template_arity_helper(F<T0 , T1> **, mpl::int_<2> *);
+    template<
+        template<typename P0 , typename P1 , typename P2> class F
+      , typename T0 , typename T1 , typename T2
+    >
+    sized_type<4>::type
+    template_arity_helper(F<T0 , T1 , T2> **, mpl::int_<3> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3> class F
+      , typename T0 , typename T1 , typename T2 , typename T3
+    >
+    sized_type<5>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3> **, mpl::int_<4> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4
+    >
+    sized_type<6>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4> **, mpl::int_<5> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5
+    >
+    sized_type<7>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5> **, mpl::int_<6> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6
+    >
+    sized_type<8>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6> **, mpl::int_<7> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7
+    >
+    sized_type<9>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7> **, mpl::int_<8> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8
+    >
+    sized_type<10>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8> **, mpl::int_<9> *);
+    template<
+        template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8 , typename P9> class F
+      , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9
+    >
+    sized_type<11>::type
+    template_arity_helper(F<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9> **, mpl::int_<10> *);

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/unpack_expr_.hpp

@@ -0,0 +1,466 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_.hpp
+    /// Contains definition of make_expr_\<\> 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 Tag, typename Domain, typename Sequence, std::size_t Size>
+    struct unpack_expr_
+    {};
+    template<typename Domain, typename Sequence>
+    struct unpack_expr_<tag::terminal, Domain, Sequence, 1u>
+    {
+        typedef
+            typename add_const<
+                typename fusion::result_of::value_of<
+                    typename fusion::result_of::begin<Sequence>::type
+                >::type
+            >::type
+        terminal_type;
+        typedef
+            typename proto::detail::protoify<
+                terminal_type
+              , Domain
+            >::result_type
+        type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence));
+        }
+    };
+    template<typename Sequence>
+    struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u>
+      : unpack_expr_<tag::terminal, default_domain, Sequence, 1u>
+    {};
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 1>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
+        typedef
+            list1<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 1>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain1<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type
+                >::type
+              , Sequence
+              , 1
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 2>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
+        typedef
+            list2<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 2>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain2<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type
+                >::type
+              , Sequence
+              , 2
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 3>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
+        typedef
+            list3<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 3>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain3<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type
+                >::type
+              , Sequence
+              , 3
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 4>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
+        typedef
+            list4<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 4>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain4<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type
+                >::type
+              , Sequence
+              , 4
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 5>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
+        typedef
+            list5<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 5>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain5<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type
+                >::type
+              , Sequence
+              , 5
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 6>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+        typedef
+            list6<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 6>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain6<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type
+                >::type
+              , Sequence
+              , 6
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 7>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+        typedef
+            list7<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 7>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain7<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type
+                >::type
+              , Sequence
+              , 7
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 8>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+        typedef
+            list8<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 8>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain8<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type
+                >::type
+              , Sequence
+              , 8
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 9>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+        typedef
+            list9<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 9>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain9<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type
+                >::type
+              , Sequence
+              , 9
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, 10>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+        typedef
+            list10<
+                typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type
+            >
+        proto_args;
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8);
+            expr_type const that = {
+                detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9)
+            };
+            return proto_generator()(that);
+        }
+    };
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, 10>
+    {
+        typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+        typedef
+            unpack_expr_<
+                Tag
+              , typename deduce_domain10<
+                    typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type
+                >::type
+              , Sequence
+              , 10
+            >
+        other;
+        typedef typename other::type type;
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/preprocessed/vararg_matches_impl.hpp

@@ -0,0 +1,178 @@
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file vararg_matches_impl.hpp
+    /// Specializations of the vararg_matches_impl 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 Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 2, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 2 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 2, 2>
+      : matches_<
+            typename detail::expr_traits<typename Args::child1>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child1>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 3, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 3 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 3, 3>
+      : matches_<
+            typename detail::expr_traits<typename Args::child2>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child2>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 4, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 4 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 4, 4>
+      : matches_<
+            typename detail::expr_traits<typename Args::child3>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child3>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 5, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 5 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 5, 5>
+      : matches_<
+            typename detail::expr_traits<typename Args::child4>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child4>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 6, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 6 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 6, 6>
+      : matches_<
+            typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 7, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 7 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 7, 7>
+      : matches_<
+            typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 8, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 8 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 8, 8>
+      : matches_<
+            typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 9, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 9 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 9, 9>
+      : matches_<
+            typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+          , Back
+        >
+    {};
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, 10, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, 10 + 1, To>
+        >
+    {};
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, 10, 10>
+      : matches_<
+            typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+          , Back
+        >
+    {};

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/remove_typename.hpp

@@ -0,0 +1,82 @@
+//==============================================================================
+//         Copyright 2003 - 2011  LASMEA UMR 6602 CNRS/Univ. Clermont II
+//         Copyright 2009 - 2011  LRI    UMR 8623 CNRS/Univ Paris Sud XI
+//         Copyright 2011         Eric Niebler
+//
+//          Distributed under the Boost Software License, Version 1.0.
+//                 See accompanying file LICENSE.txt or copy at
+//                     http://www.boost.org/LICENSE_1_0.txt
+//==============================================================================
+#ifndef BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED
+#define BOOST_PROTO_PREPROCESSOR_REMOVE_TYPENAME_HPP_INCLUDED
+
+/*!
+ * \file
+ * \brief Defines the BOOST_PROTO_REMOVE_TYPENAME macro
+ */
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/expand.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+
+//==============================================================================
+// Boost.Preprocessor author P. Mensodines confirmed on an Boost email thread
+// (subject ``check if a token is a keyword (was "BOOST_PP_IS_UNARY()")'')
+// that it is OK to used `PP_IS_UNARY()` to check if tokens match predefined
+// "keyword" as it is done by the macros below (even if `PP_IS_UNARY()` is
+// technically only part of Boost.Preprocessor private API).
+//==============================================================================
+
+//==============================================================================
+// `checking_prefix ## tokens` expand to unary (e.g., `(1)`) iff `tokens` start
+// with keyword to check.
+//==============================================================================
+#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(T, CHECKING_PREFIX)                           \
+    BOOST_PP_IS_UNARY(BOOST_PP_CAT(CHECKING_PREFIX, T))                                             \
+    /**/
+
+//==============================================================================
+// `is_front_macro(tokens)` is 1 iff `tokens` start with keyword to remove.
+// `removing_prefix ## <keyword-to-remove>` must expand to nothing.
+//==============================================================================
+#define BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT(TOKENS, IS_FRONT_MACRO, REMOVING_PREFIX)  \
+    BOOST_PP_EXPAND( /* without EXPAND doesn't expand on MSVC */                                    \
+        BOOST_PP_IIF(                                                                               \
+            IS_FRONT_MACRO(TOKENS)                                                                  \
+          , BOOST_PP_CAT                                                                            \
+          , TOKENS BOOST_PP_TUPLE_EAT(2)                                                            \
+        )(REMOVING_PREFIX, TOKENS)                                                                  \
+    )                                                                                               \
+    /**/
+
+#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_typename (1) /* unary */
+#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS (1) /* unary */
+#define BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_typename /* nothing */
+#define typename_BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE /* nothing */
+
+#define BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT(TOKENS)                                       \
+    BOOST_PROTO_DETAILS_KEYWORD_FACILITY_IS_FRONT(TOKENS, BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_IS_) \
+    /**/
+
+//==============================================================================
+/*!
+ * \ingroup preprocessor
+ * For any symbol \c X, this macro returns the same symbol from which a potential
+ * leading \c typename keyword has been removed. If no typename keyword is present,
+ * this macros evaluates to \c X itself without error.
+ *
+ * The original implementation of this macro is from Lorenzo Caminiti.
+ *
+ * \param X Symbol to remove \c typename from
+ */
+//==============================================================================
+#define BOOST_PROTO_REMOVE_TYPENAME(X)                                                              \
+    BOOST_PROTO_DETAILS_KEYWORD_FACILITY_REMOVE_FRONT(                                              \
+        X                                                                                           \
+      , BOOST_PROTO_DETAILS_KEYWORD_IS_TYPENAME_FRONT                                               \
+      , BOOST_PROTO_DETAILS_KEYWORD_TYPENAME_REMOVE_                                                \
+    )                                                                                               \
+    /**/
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/static_const.hpp

@@ -0,0 +1,27 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file static_const.hpp
+/// Contains definition of static_const for declaring static constants that 
+//
+//  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)
+
+#ifndef BOOST_PROTO_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012
+#define BOOST_PROTO_DETAIL_STATIC_CONST_HPP_EAN_20_07_2012
+
+namespace boost { namespace proto
+{
+    namespace detail
+    {
+        template<typename T>
+        struct static_const
+        {
+            static T const value;
+        };
+
+        template<typename T>
+        T const static_const<T>::value = {};
+    }
+}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/template_arity.hpp

@@ -0,0 +1,67 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file template_arity.hpp
+/// Replace all nodes stored by reference by nodes stored by value.
+//
+//  Copyright 2011 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)
+//
+//  This file is based on a similar one in MPL from Aleksey Gurtovoy.
+
+#ifndef BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07
+#define BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07
+
+// Somewhat indirect definition of BOOST_PROTO_TEMPLATE_ARITY_PARAM is
+// to overcome a shortcoming of the Wave tool used to generate the
+// pre-preprocessed headers.
+#define BOOST_PROTO_TEMPLATE_ARITY_PARAM BOOST_PROTO_TEMPLATE_ARITY_PARAM2
+#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param)
+
+#if defined(BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) ||                                   \
+  (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES))
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+#undef BOOST_PROTO_TEMPLATE_ARITY_PARAM2
+#define BOOST_PROTO_TEMPLATE_ARITY_PARAM2(param) , param
+
+namespace boost { namespace proto { namespace detail
+{
+    sized_type<1>::type template_arity_helper(...);
+
+    // Other overloads generated by the preprocessor
+    #include <boost/proto/detail/template_arity_helper.hpp>
+
+    template<typename F, int N, int Size>
+    struct template_arity_impl2
+      : mpl::int_<Size - 1>
+    {};
+
+    template<typename F, int N = BOOST_PROTO_MAX_ARITY>
+    struct template_arity
+      : template_arity_impl2<
+            F
+          , N
+          , sizeof(detail::template_arity_helper((F **)0, (mpl::int_<N> *)0))
+        >
+    {};
+
+    template<typename F, int N>
+    struct template_arity_impl2<F, N, 1>
+      : template_arity<F, N-1>
+    {};
+
+    template<typename F>
+    struct template_arity_impl2<F, 0, 1>
+      : mpl::int_<-1>
+    {};
+
+}}}
+
+#endif // BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
+#endif // BOOST_PROTO_DETAIL_TEMPLATE_ARITY_HPP_EAN_2011_05_07

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/template_arity_helper.hpp

@@ -0,0 +1,44 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/template_arity_helper.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/template_arity_helper.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // template_arity_helper.hpp
+    // Overloads of template_arity_helper, used by the template_arity\<\> 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/detail/template_arity_helper.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<
+        template<BOOST_PP_ENUM_PARAMS(N, typename P)> class F
+      , BOOST_PP_ENUM_PARAMS(N, typename T)
+    >
+    sized_type<BOOST_PP_INC(N)>::type
+    template_arity_helper(F<BOOST_PP_ENUM_PARAMS(N, T)> **, mpl::int_<N> *);
+
+    #undef N
+
+#endif // BOOST_PROTO_DONT_USE_PREPROCESSED_FILES

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/traits.hpp

@@ -0,0 +1,221 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/traits.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    #define BOOST_PROTO_CHILD(Z, N, DATA)                                                           \
+        /** INTERNAL ONLY */                                                                        \
+        typedef BOOST_PP_CAT(DATA, N) BOOST_PP_CAT(proto_child, N);                                 \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/traits.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file traits.hpp
+    /// Definitions of proto::function, proto::nary_expr and proto::result_of::child_c
+    //
+    //  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/traits.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_CHILD
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    #if N > 0
+        /// \brief A metafunction for generating function-call expression types,
+        /// a grammar element for matching function-call expressions, and a
+        /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
+        /// transform.
+        template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+        struct function
+        #if N != BOOST_PROTO_MAX_ARITY
+        <
+            BOOST_PP_ENUM_PARAMS(N, A)
+            BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+        >
+        #endif
+          : proto::transform<
+                function<
+                    BOOST_PP_ENUM_PARAMS(N, A)
+                    BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+                >
+              , int
+            >
+        {
+            typedef proto::expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
+            typedef proto::basic_expr<proto::tag::function, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
+
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<function, deduce_domain, Expr, State, Data>
+            {};
+
+            /// INTERNAL ONLY
+            typedef proto::tag::function proto_tag;
+            BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
+            BOOST_PP_REPEAT_FROM_TO(
+                N
+              , BOOST_PROTO_MAX_ARITY
+              , BOOST_PROTO_CHILD
+              , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
+            )
+        };
+
+        /// \brief A metafunction for generating n-ary expression types with a
+        /// specified tag type,
+        /// a grammar element for matching n-ary expressions, and a
+        /// PrimitiveTransform that dispatches to the <tt>pass_through\<\></tt>
+        /// transform.
+        ///
+        /// Use <tt>nary_expr\<_, vararg\<_\> \></tt> as a grammar element to match any
+        /// n-ary expression; that is, any non-terminal.
+        template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+        struct nary_expr
+        #if N != BOOST_PROTO_MAX_ARITY
+        <
+            Tag
+            BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+            BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+        >
+        #endif
+          : proto::transform<
+                nary_expr<
+                    Tag
+                    BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+                    BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void BOOST_PP_INTERCEPT)
+                >
+              , int
+            >
+        {
+            typedef proto::expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> type;
+            typedef proto::basic_expr<Tag, BOOST_PP_CAT(list, N)<BOOST_PP_ENUM_PARAMS(N, A)>, N> proto_grammar;
+
+            template<typename Expr, typename State, typename Data>
+            struct impl
+              : detail::pass_through_impl<nary_expr, deduce_domain, Expr, State, Data>
+            {};
+
+            /// INTERNAL ONLY
+            typedef Tag proto_tag;
+            BOOST_PP_REPEAT(N, BOOST_PROTO_CHILD, A)
+            BOOST_PP_REPEAT_FROM_TO(
+                N
+              , BOOST_PROTO_MAX_ARITY
+              , BOOST_PROTO_CHILD
+              , detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT
+            )
+        };
+
+        namespace detail
+        {
+            template<
+                template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class T
+              , BOOST_PP_ENUM_PARAMS(N, typename A)
+            >
+            struct is_callable_<T<BOOST_PP_ENUM_PARAMS(N, A)> BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)>
+              : is_same<BOOST_PP_CAT(A, BOOST_PP_DEC(N)), callable>
+            {};
+        }
+
+    #endif
+
+        namespace result_of
+        {
+            /// \brief A metafunction that returns the type of the Nth child
+            /// of a Proto expression.
+            ///
+            /// A metafunction that returns the type of the Nth child
+            /// of a Proto expression. \c N must be less than
+            /// \c Expr::proto_arity::value.
+            template<typename Expr>
+            struct child_c<Expr, N>
+            {
+                /// Verify that we are not operating on a terminal
+                BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+                /// The raw type of the Nth child as it is stored within
+                /// \c Expr. This may be a value or a reference
+                typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
+
+                /// The "value" type of the child, suitable for return by value,
+                /// computed as follows:
+                /// \li <tt>T const &</tt> becomes <tt>T</tt>
+                /// \li <tt>T &</tt> becomes <tt>T</tt>
+                /// \li <tt>T</tt> becomes <tt>T</tt>
+                typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::value_type type;
+            };
+
+            template<typename Expr>
+            struct child_c<Expr &, N>
+            {
+                /// Verify that we are not operating on a terminal
+                BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+                /// The raw type of the Nth child as it is stored within
+                /// \c Expr. This may be a value or a reference
+                typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
+
+                /// The "reference" type of the child, suitable for return by
+                /// reference, computed as follows:
+                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
+                /// \li <tt>T &</tt> becomes <tt>T &</tt>
+                /// \li <tt>T</tt> becomes <tt>T &</tt>
+                typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::reference type;
+
+                /// INTERNAL ONLY
+                ///
+                BOOST_FORCEINLINE
+                static type call(Expr &e)
+                {
+                    return e.proto_base().BOOST_PP_CAT(child, N);
+                }
+            };
+
+            template<typename Expr>
+            struct child_c<Expr const &, N>
+            {
+                /// Verify that we are not operating on a terminal
+                BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+                /// The raw type of the Nth child as it is stored within
+                /// \c Expr. This may be a value or a reference
+                typedef typename Expr::BOOST_PP_CAT(proto_child, N) value_type;
+
+                /// The "const reference" type of the child, suitable for return by
+                /// const reference, computed as follows:
+                /// \li <tt>T const &</tt> becomes <tt>T const &</tt>
+                /// \li <tt>T &</tt> becomes <tt>T &</tt>
+                /// \li <tt>T</tt> becomes <tt>T const &</tt>
+                typedef typename detail::expr_traits<typename Expr::BOOST_PP_CAT(proto_child, N)>::const_reference type;
+
+                /// INTERNAL ONLY
+                ///
+                BOOST_FORCEINLINE
+                static type call(Expr const &e)
+                {
+                    return e.proto_base().BOOST_PP_CAT(child, N);
+                }
+            };
+        }
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/unpack_expr_.hpp

@@ -0,0 +1,198 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/unpack_expr_.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA)                                       \
+        typedef typename fusion::result_of::next<                                                   \
+            BOOST_PP_CAT(fusion_iterator, N)>::type                                                 \
+                BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N));                                     \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_ITERATORS_TYPE(N)                                                    \
+        typedef                                                                                     \
+            typename fusion::result_of::begin<Sequence const>::type                                 \
+        fusion_iterator0;                                                                           \
+        BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator)    \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA)                                                  \
+        typename add_const<                                                                         \
+            typename fusion::result_of::value_of<                                                   \
+                BOOST_PP_CAT(fusion_iterator, N)                                                    \
+            >::type                                                                                 \
+        >::type                                                                                     \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_NEXT_ITERATOR(Z, N, DATA)                                            \
+        BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)) BOOST_PP_CAT(it, BOOST_PP_INC(N)) =          \
+            fusion::next(BOOST_PP_CAT(it, N));                                                      \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_ITERATORS(N)                                                         \
+        fusion_iterator0 it0 = fusion::begin(sequence);                                             \
+        BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR, fusion_iterator)         \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_AT(Z, N, DATA)                                                       \
+        *BOOST_PP_CAT(it, N)                                                                        \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE(Z, N, DATA)                                         \
+        typename detail::protoify<                                                                  \
+            BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA)                                                  \
+          , Domain                                                                                  \
+        >::result_type                                                                              \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_FUSION_AS_CHILD_AT(Z, N, DATA)                                              \
+        detail::protoify<                                                                           \
+            BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA)                                                  \
+          , Domain                                                                                  \
+        >()(BOOST_PROTO_FUSION_AT(Z, N, DATA))                                                      \
+        /**/
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(preserve: 2, line: 0, output: "preprocessed/unpack_expr_.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file make_expr_.hpp
+    /// Contains definition of make_expr_\<\> 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
+
+    template<typename Tag, typename Domain, typename Sequence, std::size_t Size>
+    struct unpack_expr_
+    {};
+
+    template<typename Domain, typename Sequence>
+    struct unpack_expr_<tag::terminal, Domain, Sequence, 1u>
+    {
+        typedef
+            typename add_const<
+                typename fusion::result_of::value_of<
+                    typename fusion::result_of::begin<Sequence>::type
+                >::type
+            >::type
+        terminal_type;
+
+        typedef
+            typename proto::detail::protoify<
+                terminal_type
+              , Domain
+            >::result_type
+        type;
+
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return proto::detail::protoify<terminal_type, Domain>()(fusion::at_c<0>(sequence));
+        }
+    };
+
+    template<typename Sequence>
+    struct unpack_expr_<tag::terminal, deduce_domain, Sequence, 1u>
+      : unpack_expr_<tag::terminal, default_domain, Sequence, 1u>
+    {};
+
+    #define BOOST_PP_ITERATION_PARAMS_1                                                         \
+        (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/unpack_expr_.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+    #undef BOOST_PROTO_FUSION_AT
+    #undef BOOST_PROTO_FUSION_AT_TYPE
+    #undef BOOST_PROTO_FUSION_AS_CHILD_AT
+    #undef BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE
+    #undef BOOST_PROTO_FUSION_NEXT_ITERATOR
+    #undef BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE
+    #undef BOOST_PROTO_FUSION_ITERATORS
+    #undef BOOST_PROTO_FUSION_ITERATORS_TYPE
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+    #define M BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N)
+
+    template<typename Tag, typename Domain, typename Sequence>
+    struct unpack_expr_<Tag, Domain, Sequence, N>
+    {
+        BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
+
+        typedef
+            BOOST_PP_CAT(list, N)<
+                BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT_TYPE, ~)
+            >
+        proto_args;
+
+        typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+        typedef typename Domain::proto_generator proto_generator;
+        typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            BOOST_PROTO_FUSION_ITERATORS(N)
+            expr_type const that = {
+                BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AS_CHILD_AT, ~)
+            };
+            return proto_generator()(that);
+        }
+    };
+
+    template<typename Tag, typename Sequence>
+    struct unpack_expr_<Tag, deduce_domain, Sequence, N>
+    {
+        BOOST_PROTO_FUSION_ITERATORS_TYPE(N)
+
+        typedef
+            unpack_expr_<
+                Tag
+              , typename BOOST_PP_CAT(deduce_domain, N)<
+                    BOOST_PP_ENUM(N, BOOST_PROTO_FUSION_AT_TYPE, ~)
+                >::type
+              , Sequence
+              , N
+            >
+        other;
+
+        typedef typename other::type type;
+
+        BOOST_FORCEINLINE
+        static type const call(Sequence const &sequence)
+        {
+            return other::call(sequence);
+        }
+    };
+
+    #undef N
+    #undef M
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/detail/vararg_matches_impl.hpp

@@ -0,0 +1,58 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+    #include <boost/proto/detail/preprocessed/vararg_matches_impl.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/vararg_matches_impl.hpp")
+    #endif
+
+    ///////////////////////////////////////////////////////////////////////////////
+    /// \file vararg_matches_impl.hpp
+    /// Specializations of the vararg_matches_impl 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, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/vararg_matches_impl.hpp>))
+    #include BOOST_PP_ITERATE()
+
+    #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+        #pragma wave option(output: null)
+    #endif
+
+#else // BOOST_PP_IS_ITERATING
+
+    #define N BOOST_PP_ITERATION()
+
+    template<typename Args, typename Back, long To>
+    struct vararg_matches_impl<Args, Back, N, To>
+      : and_2<
+            matches_<
+                typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr
+              , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar
+              , Back
+            >::value
+          , vararg_matches_impl<Args, Back, N + 1, To>
+        >
+    {};
+
+    template<typename Args, typename Back>
+    struct vararg_matches_impl<Args, Back, N, N>
+      : matches_<
+            typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_derived_expr
+          , typename detail::expr_traits<typename Args::BOOST_PP_CAT(child, BOOST_PP_DEC(N))>::value_type::proto_grammar
+          , Back
+        >
+    {};
+
+    #undef N
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/domain.hpp

@@ -0,0 +1,337 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file domain.hpp
+/// Contains definition of domain\<\> class template and helpers for
+/// defining domains with a generator and a grammar for controlling
+/// operator overloading.
+//
+//  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)
+
+#ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
+#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
+
+#include <boost/ref.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/generate.hpp>
+#include <boost/proto/detail/as_expr.hpp>
+#include <boost/proto/detail/deduce_domain.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+
+    namespace detail
+    {
+        struct not_a_generator
+        {};
+
+        struct not_a_grammar
+        {};
+
+        struct not_a_domain
+        {};
+    }
+
+    namespace domainns_
+    {
+        /// \brief For use in defining domain tags to be used
+        /// with \c proto::extends\<\>. A \e Domain associates
+        /// an expression type with a \e Generator, and optionally
+        /// a \e Grammar.
+        ///
+        /// The Generator determines how new expressions in the
+        /// domain are constructed. Typically, a generator wraps
+        /// all new expressions in a wrapper that imparts
+        /// domain-specific behaviors to expressions within its
+        /// domain. (See \c proto::extends\<\>.)
+        ///
+        /// The Grammar determines whether a given expression is
+        /// valid within the domain, and automatically disables
+        /// any operator overloads which would cause an invalid
+        /// expression to be created. By default, the Grammar
+        /// parameter defaults to the wildcard, \c proto::_, which
+        /// makes all expressions valid within the domain.
+        ///
+        /// The Super declares the domain currently being defined
+        /// to be a sub-domain of Super. Expressions in sub-domains
+        /// can be freely combined with expressions in its super-
+        /// domain (and <I>its</I> super-domain, etc.).
+        ///
+        /// Example:
+        /// \code
+        /// template<typename Expr>
+        /// struct MyExpr;
+        ///
+        /// struct MyGrammar
+        ///   : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
+        /// {};
+        ///
+        /// // Define MyDomain, in which all expressions are
+        /// // wrapped in MyExpr<> and only expressions that
+        /// // conform to MyGrammar are allowed.
+        /// struct MyDomain
+        ///   : domain<generator<MyExpr>, MyGrammar>
+        /// {};
+        ///
+        /// // Use MyDomain to define MyExpr
+        /// template<typename Expr>
+        /// struct MyExpr
+        ///   : extends<Expr, MyExpr<Expr>, MyDomain>
+        /// {
+        ///     // ...
+        /// };
+        /// \endcode
+        ///
+        template<
+            typename Generator // = default_generator
+          , typename Grammar   // = proto::_
+          , typename Super     // = no_super_domain
+        >
+        struct domain
+          : Generator
+        {
+            typedef Generator proto_generator;
+            typedef Grammar   proto_grammar;
+            typedef Super     proto_super_domain;
+            typedef domain    proto_base_domain;
+
+            /// INTERNAL ONLY
+            typedef void proto_is_domain_;
+
+            /// \brief A unary MonomorphicFunctionObject that turns objects into Proto
+            /// expression objects in this domain.
+            ///
+            /// The <tt>as_expr\<\></tt> function object turns objects into Proto expressions, if
+            /// they are not already, by making them Proto terminals held by value if
+            /// possible. Objects that are already Proto expressions are left alone.
+            ///
+            /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr;
+            /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T:
+            ///
+            /// If \c T is not a Proto expression type the resulting terminal is
+            /// calculated as follows:
+            ///
+            ///   If \c T is a function type, an abstract type, or a type derived from
+            ///   \c std::ios_base, let \c A be <tt>T &</tt>.
+            ///   Otherwise, let \c A be the type \c T stripped of cv-qualifiers.
+            ///   Then, the result of applying <tt>as_expr\<T\>()(t)</tt> is
+            ///   <tt>Generator()(E\<tag::terminal, term\<A\> \>::make(t))</tt>.
+            ///
+            /// If \c T is a Proto expression type and its generator type is different from
+            /// \c Generator, the result is <tt>Generator()(t)</tt>.
+            ///
+            /// Otherwise, the result is \c t converted to an (un-const) rvalue.
+            ///
+            template<typename T, typename IsExpr = void, typename Callable = proto::callable>
+            struct as_expr
+              : detail::as_expr<
+                    T
+                  , typename detail::base_generator<Generator>::type
+                  , wants_basic_expr<Generator>::value
+                >
+            {
+                BOOST_PROTO_CALLABLE()
+            };
+
+            /// INTERNAL ONLY
+            ///
+            template<typename T>
+            struct as_expr<T, typename T::proto_is_expr_, proto::callable>
+            {
+                BOOST_PROTO_CALLABLE()
+                typedef typename remove_const<T>::type result_type;
+
+                BOOST_FORCEINLINE
+                result_type operator()(T &e) const
+                {
+                    return e;
+                }
+            };
+
+            /// \brief A unary MonomorphicFunctionObject that turns objects into Proto
+            /// expression objects in this domain.
+            ///
+            /// The <tt>as_child\<\></tt> function object turns objects into Proto expressions, if
+            /// they are not already, by making them Proto terminals held by reference.
+            /// Objects that are already Proto expressions are simply returned by reference.
+            ///
+            /// If <tt>wants_basic_expr\<Generator\>::value</tt> is true, then let \c E be \c basic_expr;
+            /// otherwise, let \t E be \c expr. Given an lvalue \c t of type \c T:
+            ///
+            /// If \c T is not a Proto expression type the resulting terminal is
+            /// <tt>Generator()(E\<tag::terminal, term\<T &\> \>::make(t))</tt>.
+            ///
+            /// If \c T is a Proto expression type and its generator type is different from
+            /// \c Generator, the result is <tt>Generator()(t)</tt>.
+            ///
+            /// Otherwise, the result is the lvalue \c t.
+            ///
+            template<typename T, typename IsExpr = void, typename Callable = proto::callable>
+            struct as_child
+              : detail::as_child<
+                    T
+                  , typename detail::base_generator<Generator>::type
+                  , wants_basic_expr<Generator>::value
+                >
+            {
+                BOOST_PROTO_CALLABLE()
+            };
+
+            /// INTERNAL ONLY
+            ///
+            template<typename T>
+            struct as_child<T, typename T::proto_is_expr_, proto::callable>
+            {
+                BOOST_PROTO_CALLABLE()
+                typedef T &result_type;
+
+                BOOST_FORCEINLINE
+                result_type operator()(T &e) const
+                {
+                    return e;
+                }
+            };
+        };
+
+        /// \brief The domain expressions have by default, if
+        /// \c proto::extends\<\> has not been used to associate
+        /// a domain with an expression.
+        ///
+        struct default_domain
+          : domain<>
+        {};
+
+        /// \brief A domain to use when you prefer the use of
+        /// \c proto::basic_expr\<\> over \c proto::expr\<\>.
+        ///
+        struct basic_default_domain
+          : domain<basic_default_generator>
+        {};
+
+        /// \brief A pseudo-domain for use in functions and
+        /// metafunctions that require a domain parameter. It
+        /// indicates that the domain of the parent node should
+        /// be inferred from the domains of the child nodes.
+        ///
+        /// \attention \c deduce_domain is not itself a valid domain.
+        ///
+        struct deduce_domain
+          : domain<detail::not_a_generator, detail::not_a_grammar, detail::not_a_domain>
+        {};
+
+        /// \brief Given a domain, a tag type and an argument list,
+        /// compute the type of the expression to generate. This is
+        /// either an instance of \c proto::expr\<\> or
+        /// \c proto::basic_expr\<\>.
+        ///
+        template<typename Domain, typename Tag, typename Args, bool WantsBasicExpr>
+        struct base_expr
+        {
+            typedef proto::expr<Tag, Args, Args::arity> type;
+        };
+
+        /// INTERNAL ONLY
+        ///
+        template<typename Domain, typename Tag, typename Args>
+        struct base_expr<Domain, Tag, Args, true>
+        {
+            typedef proto::basic_expr<Tag, Args, Args::arity> type;
+        };
+
+    }
+
+    /// A metafunction that returns \c mpl::true_
+    /// if the type \c T is the type of a Proto domain;
+    /// \c mpl::false_ otherwise. If \c T inherits from
+    /// \c proto::domain\<\>, \c is_domain\<T\> is
+    /// \c mpl::true_.
+    template<typename T, typename Void  /* = void*/>
+    struct is_domain
+      : mpl::false_
+    {};
+
+    /// INTERNAL ONLY
+    ///
+    template<typename T>
+    struct is_domain<T, typename T::proto_is_domain_>
+      : mpl::true_
+    {};
+
+    /// A metafunction that returns the domain of
+    /// a given type. If \c T is a Proto expression
+    /// type, it returns that expression's associated
+    /// domain. If not, it returns
+    /// \c proto::default_domain.
+    template<typename T, typename Void /* = void*/>
+    struct domain_of
+    {
+        typedef default_domain type;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename T>
+    struct domain_of<T, typename T::proto_is_expr_>
+    {
+        typedef typename T::proto_domain type;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename T>
+    struct domain_of<T &, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename T>
+    struct domain_of<boost::reference_wrapper<T>, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+
+    /// INTERNAL ONLY
+    ///
+    template<typename T>
+    struct domain_of<boost::reference_wrapper<T> const, void>
+    {
+        typedef typename domain_of<T>::type type;
+    };
+
+    /// A metafunction that returns \c mpl::true_
+    /// if the type \c SubDomain is a sub-domain of
+    /// \c SuperDomain; \c mpl::false_ otherwise.
+    template<typename SubDomain, typename SuperDomain>
+    struct is_sub_domain_of
+      : is_sub_domain_of<typename SubDomain::proto_super_domain, SuperDomain>
+    {};
+
+    /// INTERNAL ONLY
+    ///
+    template<typename SuperDomain>
+    struct is_sub_domain_of<proto::no_super_domain, SuperDomain>
+      : mpl::false_
+    {};
+
+    /// INTERNAL ONLY
+    ///
+    template<typename SuperDomain>
+    struct is_sub_domain_of<SuperDomain, SuperDomain>
+      : mpl::true_
+    {};
+
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/eval.hpp

@@ -0,0 +1,140 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file eval.hpp
+/// Contains the eval() expression evaluator.
+//
+//  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)
+
+#ifndef BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
+#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
+
+#include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace proto
+{
+
+    namespace result_of
+    {
+        /// \brief A metafunction for calculating the return type
+        /// of \c proto::eval() given a certain \c Expr and \c Context
+        /// types.
+        ///
+        /// \note The types \c Expr and \c Context should not be
+        /// reference types. They may be cv-qualified, but the
+        /// cv-qualification on the \c Context parameter is ignored.
+        template<typename Expr, typename Context>
+        struct eval
+        {
+            typedef typename Context::template eval<Expr>::result_type type;
+        };
+    }
+
+    namespace functional
+    {
+        /// \brief A PolymorphicFunctionObject type for
+        /// evaluating a given Proto expression with a given
+        /// context.
+        struct eval
+        {
+            BOOST_PROTO_CALLABLE()
+
+            template<typename Sig>
+            struct result;
+
+            template<typename This, typename Expr, typename Context>
+            struct result<This(Expr, Context)>
+            {
+                typedef
+                    typename proto::result_of::eval<
+                        typename remove_reference<Expr>::type
+                      , typename remove_reference<Context>::type
+                    >::type
+                type;
+            };
+
+            /// \brief Evaluate a given Proto expression with a given
+            /// context.
+            /// \param expr The Proto expression to evaluate
+            /// \param context The context in which the expression should be
+            ///     evaluated.
+            /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr, Context>::type
+            operator ()(Expr &e, Context &ctx) const
+            {
+                return typename Context::template eval<Expr>()(e, ctx);
+            }
+
+            /// \overload
+            ///
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr, Context>::type
+            operator ()(Expr &e, Context const &ctx) const
+            {
+                return typename Context::template eval<Expr>()(e, ctx);
+            }
+
+            /// \overload
+            ///
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr const, Context>::type
+            operator ()(Expr const &e, Context &ctx) const
+            {
+                return typename Context::template eval<Expr const>()(e, ctx);
+            }
+
+            /// \overload
+            ///
+            template<typename Expr, typename Context>
+            typename proto::result_of::eval<Expr const, Context>::type
+            operator ()(Expr const &e, Context const &ctx) const
+            {
+                return typename Context::template eval<Expr const>()(e, ctx);
+            }
+        };
+    }
+
+    /// \brief Evaluate a given Proto expression with a given
+    /// context.
+    /// \param expr The Proto expression to evaluate
+    /// \param context The context in which the expression should be
+    ///     evaluated.
+    /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr, Context>::type
+    eval(Expr &e, Context &ctx)
+    {
+        return typename Context::template eval<Expr>()(e, ctx);
+    }
+
+    /// \overload
+    ///
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr, Context>::type
+    eval(Expr &e, Context const &ctx)
+    {
+        return typename Context::template eval<Expr>()(e, ctx);
+    }
+
+    /// \overload
+    ///
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr const, Context>::type
+    eval(Expr const &e, Context &ctx)
+    {
+        return typename Context::template eval<Expr const>()(e, ctx);
+    }
+
+    /// \overload
+    ///
+    template<typename Expr, typename Context>
+    typename proto::result_of::eval<Expr const, Context>::type
+    eval(Expr const &e, Context const &ctx)
+    {
+        return typename Context::template eval<Expr const>()(e, ctx);
+    }
+}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/expr.hpp

@@ -0,0 +1,175 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file expr.hpp
+/// Contains definition of expr\<\> 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)
+
+#ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
+#define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/selection/max.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_trailing.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/args.hpp>
+#include <boost/proto/traits.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4510) // default constructor could not be generated
+# pragma warning(disable : 4512) // assignment operator could not be generated
+# pragma warning(disable : 4610) // user defined constructor required
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+
+    namespace detail
+    {
+        struct not_a_valid_type
+        {
+        private:
+            not_a_valid_type()
+            {}
+        };
+        
+        template<typename Tag, typename Arg>
+        struct address_of_hack
+        {
+            typedef not_a_valid_type type;
+        };
+
+        template<typename Expr>
+        struct address_of_hack<proto::tag::address_of, Expr &>
+        {
+            typedef Expr *type;
+        };
+
+        template<typename T, typename Expr, typename Arg0>
+        BOOST_FORCEINLINE
+        Expr make_terminal(T &t, Expr *, proto::term<Arg0> *)
+        {
+            Expr that = {t};
+            return that;
+        }
+
+        template<typename T, typename Expr, typename Arg0, std::size_t N>
+        BOOST_FORCEINLINE
+        Expr make_terminal(T (&t)[N], Expr *, proto::term<Arg0[N]> *)
+        {
+            Expr that;
+            for(std::size_t i = 0; i < N; ++i)
+            {
+                that.child0[i] = t[i];
+            }
+            return that;
+        }
+
+        template<typename T, typename Expr, typename Arg0, std::size_t N>
+        BOOST_FORCEINLINE
+        Expr make_terminal(T const(&t)[N], Expr *, proto::term<Arg0[N]> *)
+        {
+            Expr that;
+            for(std::size_t i = 0; i < N; ++i)
+            {
+                that.child0[i] = t[i];
+            }
+            return that;
+        }
+
+        // Work-around for:
+        // https://connect.microsoft.com/VisualStudio/feedback/details/765449/codegen-stack-corruption-using-runtime-checks-when-aggregate-initializing-struct
+    #if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+        template<typename T, typename Expr, typename C, typename U>
+        BOOST_FORCEINLINE
+        Expr make_terminal(T &t, Expr *, proto::term<U C::*> *)
+        {
+            Expr that;
+            that.child0 = t;
+            return that;
+        }
+    #endif
+
+        template<typename T, typename U>
+        struct same_cv
+        {
+            typedef U type;
+        };
+
+        template<typename T, typename U>
+        struct same_cv<T const, U>
+        {
+            typedef U const type;
+        };
+    }
+
+    namespace result_of
+    {
+        /// \brief A helper metafunction for computing the
+        /// return type of \c proto::expr\<\>::operator().
+        template<typename Sig, typename This, typename Domain>
+        struct funop;
+
+        #include <boost/proto/detail/funop.hpp>
+    }
+
+    namespace exprns_
+    {
+        // This is where the basic_expr specializations are
+        // actually defined:
+        #include <boost/proto/detail/basic_expr.hpp>
+
+        #if defined(__GNUC__) && __GNUC__ >= 9 || defined(__clang__) && __clang_major__ >= 10
+            #pragma GCC diagnostic push
+            // The warning cannot be fixed for aggregates
+            // Sadly, GCC currently emits the warning at the use location:
+            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94492
+            #pragma GCC diagnostic ignored "-Wdeprecated-copy"
+        #endif
+
+        // This is where the expr specialization are
+        // actually defined:
+        #include <boost/proto/detail/expr.hpp>
+
+        #if defined(__GNUC__) && __GNUC__ >= 9 || defined(__clang__) && __clang_major__ >= 10
+            #pragma GCC diagnostic pop
+        #endif
+    }
+
+    /// \brief Lets you inherit the interface of an expression
+    /// while hiding from Proto the fact that the type is a Proto
+    /// expression.
+    template<typename Expr>
+    struct unexpr
+      : Expr
+    {
+        BOOST_PROTO_UNEXPR()
+
+        BOOST_FORCEINLINE
+        explicit unexpr(Expr const &e)
+          : Expr(e)
+        {}
+        
+        using Expr::operator =;
+    };
+
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif // BOOST_PROTO_EXPR_HPP_EAN_04_01_2005

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/extends.hpp

@@ -0,0 +1,655 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file extends.hpp
+/// Macros and a base class for defining end-user expression types
+//
+//  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)
+
+#ifndef BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
+#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
+
+#include <cstddef> // for offsetof
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/expr.hpp>
+#include <boost/proto/args.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/generate.hpp>
+#include <boost/proto/detail/remove_typename.hpp>
+
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
+#endif
+
+namespace boost { namespace proto
+{
+    #ifdef __GNUC__
+    /// INTERNAL ONLY
+    ///
+    # define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x))
+    /// INTERNAL ONLY
+    ///
+    # define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this)))
+    #else
+    /// INTERNAL ONLY
+    ///
+    # define BOOST_PROTO_OFFSETOF offsetof
+    #endif
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_CONST() const
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_TYPENAME() typename
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_TEMPLATE_NO_(Z, N)
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const)                                      \
+        BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N)                   \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+        BOOST_PROTO_DISABLE_MSVC_C4180                                                              \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        typename BOOST_PROTO_RESULT_OF<                                                             \
+            proto_generator(                                                                        \
+                typename boost::proto::result_of::BOOST_PP_CAT(funop, N)<                           \
+                    proto_derived_expr Const()                                                      \
+                  , proto_domain                                                                    \
+                    BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A)                                  \
+                >::type                                                                             \
+            )                                                                                       \
+        >::type const                                                                               \
+        operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const()                       \
+        {                                                                                           \
+            typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)<                                \
+                proto_derived_expr Const()                                                          \
+              , proto_domain                                                                        \
+                BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A)                                      \
+            > funop;                                                                                \
+            return proto_generator()(                                                               \
+                funop::call(                                                                        \
+                    *static_cast<proto_derived_expr Const() *>(this)                                \
+                    BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a)                                        \
+                )                                                                                   \
+            );                                                                                      \
+        }                                                                                           \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const)                                         \
+        template<typename... A>                                                                     \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+        BOOST_PROTO_DISABLE_MSVC_C4180                                                              \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        typename BOOST_PROTO_RESULT_OF<                                                             \
+            proto_generator(                                                                        \
+                typename boost::proto::result_of::funop<                                            \
+                    proto_derived_expr Const()(A const &...)                                        \
+                  , proto_derived_expr                                                              \
+                  , proto_domain                                                                    \
+                >::type                                                                             \
+            )                                                                                       \
+        >::type const                                                                               \
+        operator ()(A const &...a) Const()                                                          \
+        {                                                                                           \
+            typedef boost::proto::result_of::funop<                                                 \
+                proto_derived_expr Const()(A const &...)                                            \
+              , proto_derived_expr                                                                  \
+              , proto_domain                                                                        \
+            > funop;                                                                                \
+            return proto_generator()(                                                               \
+                funop::call(                                                                        \
+                    *static_cast<proto_derived_expr Const() *>(this)                                \
+                  , a...                                                                            \
+                )                                                                                   \
+            );                                                                                      \
+        }                                                                                           \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA)                                             \
+        BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST)                              \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA)                                         \
+        BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY)                                 \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA)                                                   \
+        BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA)                                                 \
+        BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA)                                             \
+        /**/
+
+    /// INTERNAL ONLY
+    ///
+    #define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA)                                                   \
+        typedef                                                                                     \
+            typename proto_base_expr::BOOST_PP_CAT(proto_child, N)                                  \
+        BOOST_PP_CAT(proto_child, N);                                                               \
+        /**/
+
+    #define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)                                       \
+        Expr proto_expr_;                                                                           \
+                                                                                                    \
+        typedef Expr proto_base_expr_; /**< INTERNAL ONLY */                                        \
+        typedef typename proto_base_expr_::proto_base_expr proto_base_expr;                         \
+        typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain;                                   \
+        typedef Derived proto_derived_expr;                                                         \
+        typedef Domain::proto_generator proto_generator;                                            \
+        typedef typename proto_base_expr::proto_tag proto_tag;                                      \
+        typedef typename proto_base_expr::proto_args proto_args;                                    \
+        typedef typename proto_base_expr::proto_arity proto_arity;                                  \
+        typedef typename proto_base_expr::proto_grammar proto_grammar;                              \
+        typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_;        \
+        typedef void proto_is_expr_; /**< INTERNAL ONLY */                                          \
+        static const long proto_arity_c = proto_base_expr::proto_arity_c;                           \
+        typedef boost::proto::tag::proto_expr<proto_tag, proto_domain> fusion_tag;                  \
+        BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~)                        \
+                                                                                                    \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+                                                                                                    \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        static proto_derived_expr const make(Expr const &e)                                         \
+        {                                                                                           \
+            proto_derived_expr that = {e};                                                          \
+            return that;                                                                            \
+        }                                                                                           \
+                                                                                                    \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        proto_base_expr &proto_base()                                                               \
+        {                                                                                           \
+            return this->proto_expr_.proto_base();                                                  \
+        }                                                                                           \
+                                                                                                    \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        proto_base_expr const &proto_base() const                                                   \
+        {                                                                                           \
+            return this->proto_expr_.proto_base();                                                  \
+        }                                                                                           \
+                                                                                                    \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        operator proto_address_of_hack_type_() const                                                \
+        {                                                                                           \
+            return boost::addressof(this->proto_base().child0);                                     \
+        }                                                                                           \
+                                                                                                    \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+    #define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain)                                        \
+        BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)                                           \
+        typedef void proto_is_aggregate_;                                                           \
+        /**< INTERNAL ONLY */
+
+    #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename)                            \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+        BOOST_PROTO_DISABLE_MSVC_C4522                                                              \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        Typename() BOOST_PROTO_RESULT_OF<                                                           \
+            Typename() This::proto_generator(                                                       \
+                Typename() boost::proto::base_expr<                                                 \
+                    Typename() This::proto_domain                                                   \
+                  , boost::proto::tag::assign                                                       \
+                  , boost::proto::list2<                                                            \
+                        This &                                                                      \
+                      , This Const() &                                                              \
+                    >                                                                               \
+                >::type                                                                             \
+            )                                                                                       \
+        >::type const                                                                               \
+        operator =(This Const() &a)                                                                 \
+        {                                                                                           \
+            typedef                                                                                 \
+                Typename() boost::proto::base_expr<                                                 \
+                    Typename() This::proto_domain                                                   \
+                  , boost::proto::tag::assign                                                       \
+                  , boost::proto::list2<                                                            \
+                        This &                                                                      \
+                      , This Const() &                                                              \
+                    >                                                                               \
+                >::type                                                                             \
+            that_type;                                                                              \
+            that_type const that = {                                                                \
+                *this                                                                               \
+              , a                                                                                   \
+            };                                                                                      \
+            return Typename() This::proto_generator()(that);                                        \
+        }                                                                                           \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+        // MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both*
+        // const and non-const rhs arguments.
+    #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310)
+        #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename)                                    \
+            BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename)                   \
+            BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename)                \
+            /**/
+    #else
+        #define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename)                                    \
+            BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename)                \
+            /**/
+    #endif
+
+        /// INTERNAL ONLY
+        ///
+    #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst)                                  \
+        template<typename A>                                                                        \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+        BOOST_PROTO_DISABLE_MSVC_C4180                                                              \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        typename BOOST_PROTO_RESULT_OF<                                                             \
+            proto_generator(                                                                        \
+                typename boost::proto::base_expr<                                                   \
+                    proto_domain                                                                    \
+                  , boost::proto::tag::assign                                                       \
+                  , boost::proto::list2<                                                            \
+                        proto_derived_expr ThisConst() &                                            \
+                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
+                    >                                                                               \
+                >::type                                                                             \
+            )                                                                                       \
+        >::type const                                                                               \
+        operator =(A ThatConst() &a) ThisConst()                                                    \
+        {                                                                                           \
+            typedef                                                                                 \
+                typename boost::proto::base_expr<                                                   \
+                    proto_domain                                                                    \
+                  , boost::proto::tag::assign                                                       \
+                  , boost::proto::list2<                                                            \
+                        proto_derived_expr ThisConst() &                                            \
+                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
+                    >                                                                               \
+                >::type                                                                             \
+            that_type;                                                                              \
+            that_type const that = {                                                                \
+                *static_cast<proto_derived_expr ThisConst() *>(this)                                \
+              , boost::proto::as_child<proto_domain>(a)                                             \
+            };                                                                                      \
+            return proto_generator()(that);                                                         \
+        }                                                                                           \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN_CONST_()                                                     \
+        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY)                         \
+        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST)                      \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_()                                                 \
+        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY)                            \
+        BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST)                         \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN_()                                                           \
+        BOOST_PROTO_EXTENDS_ASSIGN_CONST_()                                                         \
+        BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_()                                                     \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN_CONST()                                                      \
+        BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME)                  \
+        BOOST_PROTO_EXTENDS_ASSIGN_CONST_()                                                         \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST()                                                  \
+        BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME)                  \
+        BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_()                                                     \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_ASSIGN()                                                            \
+        BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME)                  \
+        BOOST_PROTO_EXTENDS_ASSIGN_()                                                               \
+        /**/
+
+        /// INTERNAL ONLY
+        ///
+    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst)                               \
+        template<typename A>                                                                        \
+        BOOST_PROTO_PUSH_WARNINGS                                                                   \
+        BOOST_PROTO_DISABLE_MSVC_C4180                                                              \
+        BOOST_PROTO_DISABLE_MSVC_C4714 BOOST_FORCEINLINE                                            \
+        typename BOOST_PROTO_RESULT_OF<                                                             \
+            proto_generator(                                                                        \
+                typename boost::proto::base_expr<                                                   \
+                    proto_domain                                                                    \
+                  , boost::proto::tag::subscript                                                    \
+                  , boost::proto::list2<                                                            \
+                        proto_derived_expr ThisConst() &                                            \
+                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
+                    >                                                                               \
+                >::type                                                                             \
+            )                                                                                       \
+        >::type const                                                                               \
+        operator [](A ThatConst() &a) ThisConst()                                                   \
+        {                                                                                           \
+            typedef                                                                                 \
+                typename boost::proto::base_expr<                                                   \
+                    proto_domain                                                                    \
+                  , boost::proto::tag::subscript                                                    \
+                  , boost::proto::list2<                                                            \
+                        proto_derived_expr ThisConst() &                                            \
+                      , typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
+                    >                                                                               \
+                >::type                                                                             \
+            that_type;                                                                              \
+            that_type const that = {                                                                \
+                *static_cast<proto_derived_expr ThisConst() *>(this)                                \
+              , boost::proto::as_child<proto_domain>(a)                                             \
+            };                                                                                      \
+            return proto_generator()(that);                                                         \
+        }                                                                                           \
+        BOOST_PROTO_POP_WARNINGS                                                                    \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()                                                   \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY)                      \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST)                   \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST()                                               \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY)                         \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST)                      \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_SUBSCRIPT()                                                         \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()                                                       \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST()                                                   \
+        /**/
+
+        /// INTERNAL ONLY
+        ///
+    #define BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+        template<typename Sig>                                                                      \
+        struct result                                                                               \
+        {                                                                                           \
+            typedef                                                                                 \
+                typename BOOST_PROTO_RESULT_OF<                                                     \
+                    proto_generator(                                                                \
+                        typename boost::proto::result_of::funop<                                    \
+                            Sig                                                                     \
+                          , proto_derived_expr                                                      \
+                          , proto_domain                                                            \
+                        >::type                                                                     \
+                    )                                                                               \
+                >::type const                                                                       \
+            type;                                                                                   \
+        };                                                                                          \
+        /**/
+
+    #ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+        #define BOOST_PROTO_EXTENDS_FUNCTION_CONST()                                                \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)                             \
+            /**/
+
+        #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST()                                            \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY)                                \
+            /**/
+
+        #define BOOST_PROTO_EXTENDS_FUNCTION()                                                      \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY)                                \
+            BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST)                             \
+            /**/
+    #else
+        #define BOOST_PROTO_EXTENDS_FUNCTION_CONST()                                                \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PP_REPEAT_FROM_TO(                                                                \
+                0                                                                                   \
+              , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY                                                 \
+              , BOOST_PROTO_DEFINE_FUN_OP_CONST                                                     \
+              , ~                                                                                   \
+            )                                                                                       \
+            /**/
+
+        #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST()                                            \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PP_REPEAT_FROM_TO(                                                                \
+                0                                                                                   \
+              , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY                                                 \
+              , BOOST_PROTO_DEFINE_FUN_OP_NON_CONST                                                 \
+              , ~                                                                                   \
+            )                                                                                       \
+            /**/
+
+        #define BOOST_PROTO_EXTENDS_FUNCTION()                                                      \
+            BOOST_PROTO_EXTENDS_FUNCTION_()                                                         \
+            BOOST_PP_REPEAT_FROM_TO(                                                                \
+                0                                                                                   \
+              , BOOST_PROTO_MAX_FUNCTION_CALL_ARITY                                                 \
+              , BOOST_PROTO_DEFINE_FUN_OP                                                           \
+              , ~                                                                                   \
+            )                                                                                       \
+            /**/
+    #endif
+
+    #define BOOST_PROTO_EXTENDS(Expr, Derived, Domain)                                              \
+        BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain)                                            \
+        BOOST_PROTO_EXTENDS_ASSIGN()                                                                \
+        BOOST_PROTO_EXTENDS_SUBSCRIPT()                                                             \
+        BOOST_PROTO_EXTENDS_FUNCTION()                                                              \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived)                                               \
+        typedef typename Derived::proto_extends proto_extends;                                      \
+        using proto_extends::operator =;                                                            \
+        BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME)                             \
+        /**/
+
+    #define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived)                                 \
+        typedef Derived::proto_extends proto_extends;                                               \
+        using proto_extends::operator =;                                                            \
+        BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY)                                   \
+        /**/
+
+    namespace exprns_
+    {
+        /// \brief Empty type to be used as a dummy template parameter of
+        ///     POD expression wrappers. It allows argument-dependent lookup
+        ///     to find Proto's operator overloads.
+        ///
+        /// \c proto::is_proto_expr allows argument-dependent lookup
+        ///     to find Proto's operator overloads. For example:
+        ///
+        /// \code
+        /// template<typename T, typename Dummy = proto::is_proto_expr>
+        /// struct my_terminal
+        /// {
+        ///     BOOST_PROTO_BASIC_EXTENDS(
+        ///         typename proto::terminal<T>::type
+        ///       , my_terminal<T>
+        ///       , default_domain
+        ///     )
+        /// };
+        ///
+        /// // ...
+        /// my_terminal<int> _1, _2;
+        /// _1 + _2; // OK, uses proto::operator+
+        /// \endcode
+        ///
+        /// Without the second \c Dummy template parameter, Proto's operator
+        /// overloads would not be considered by name lookup.
+        struct is_proto_expr
+        {};
+
+        /// \brief extends\<\> class template for adding behaviors to a Proto expression template
+        ///
+        template<
+            typename Expr
+          , typename Derived
+          , typename Domain     // = proto::default_domain
+          , long Arity          // = Expr::proto_arity_c
+        >
+        struct extends
+        {
+            BOOST_FORCEINLINE
+            extends()
+              : proto_expr_()
+            {}
+
+            BOOST_FORCEINLINE
+            extends(Expr const &expr_)
+              : proto_expr_(expr_)
+            {}
+
+            typedef extends proto_extends;
+            BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
+            BOOST_PROTO_EXTENDS_ASSIGN_CONST_()
+            BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
+
+            // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+            // nested preprocessor loops, use file iteration here to generate
+            // the operator() overloads, which is more efficient.
+            #include <boost/proto/detail/extends_funop_const.hpp>
+        };
+
+        /// \brief extends\<\> class template for adding behaviors to a Proto expression template
+        ///
+        template<typename Expr, typename Derived, typename Domain>
+        struct extends<Expr, Derived, Domain, 0>
+        {
+            BOOST_FORCEINLINE
+            extends()
+              : proto_expr_()
+            {}
+
+            BOOST_FORCEINLINE
+            extends(Expr const &expr_)
+              : proto_expr_(expr_)
+            {}
+
+            typedef extends proto_extends;
+            BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
+            BOOST_PROTO_EXTENDS_ASSIGN_()
+            BOOST_PROTO_EXTENDS_SUBSCRIPT()
+
+            // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+            // nested preprocessor loops, use file iteration here to generate
+            // the operator() overloads, which is more efficient.
+            #include <boost/proto/detail/extends_funop.hpp>
+        };
+
+        /// INTERNAL ONLY
+        ///
+        template<typename This, typename Fun, typename Domain>
+        struct virtual_member
+        {
+            typedef Domain proto_domain;
+            typedef typename Domain::proto_generator proto_generator;
+            typedef virtual_member<This, Fun, Domain> proto_derived_expr;
+            typedef tag::member proto_tag;
+            typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
+            typedef mpl::long_<2> proto_arity;
+            typedef detail::not_a_valid_type proto_address_of_hack_type_;
+            typedef void proto_is_expr_; /**< INTERNAL ONLY */
+            static const long proto_arity_c = 2;
+            typedef boost::proto::tag::proto_expr<proto_tag, Domain> fusion_tag;
+            typedef This &proto_child0;
+            typedef expr<tag::terminal, term<Fun> > const &proto_child1;
+            typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
+            typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
+            typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
+
+            BOOST_PROTO_EXTENDS_ASSIGN_()
+            BOOST_PROTO_EXTENDS_SUBSCRIPT()
+
+            // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+            // nested preprocessor loops, use file iteration here to generate
+            // the operator() overloads, which is more efficient.
+            #define BOOST_PROTO_NO_WAVE_OUTPUT
+            #include <boost/proto/detail/extends_funop.hpp>
+            #undef BOOST_PROTO_NO_WAVE_OUTPUT
+
+            BOOST_FORCEINLINE
+            proto_base_expr const proto_base() const
+            {
+                proto_base_expr that = {this->child0(), this->child1()};
+                return that;
+            }
+
+            BOOST_FORCEINLINE
+            proto_child0 child0() const
+            {
+                using std::size_t;
+                return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
+            }
+
+            BOOST_FORCEINLINE
+            proto_child1 child1() const
+            {
+                static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
+                return that;
+            }
+        };
+
+        /// INTERNAL ONLY
+        ///
+        #define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM)                                            \
+            boost::proto::exprns_::virtual_member<                                                      \
+                proto_derived_expr                                                                      \
+              , BOOST_PP_TUPLE_ELEM(2, 0, ELEM)                                                         \
+              , DOMAIN                                                                                  \
+            > BOOST_PP_TUPLE_ELEM(2, 1, ELEM);                                                          \
+            /**/
+
+        /// \brief For declaring virtual data members in an extension class.
+        ///
+        #define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN)                                    \
+            union                                                                                       \
+            {                                                                                           \
+                char proto_member_union_start_;                                                         \
+                BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ)                         \
+            };                                                                                          \
+            /**/
+
+        /// \brief For declaring virtual data members in an extension class.
+        ///
+        #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ)                                                        \
+            BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain)                                  \
+            /**/
+
+    }
+
+}}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional.hpp

@@ -0,0 +1,16 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file functional.hpp
+/// Proto callables for various things
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_HPP_EAN_11_27_2010
+
+#include <boost/proto/functional/std.hpp>
+#include <boost/proto/functional/fusion.hpp>
+#include <boost/proto/functional/range.hpp>
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion.hpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file fusion.hpp
+/// Proto callables for things found in the Fusion library
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_HPP_EAN_11_27_2010
+
+#include <boost/proto/functional/fusion/at.hpp>
+#include <boost/proto/functional/fusion/pop_back.hpp>
+#include <boost/proto/functional/fusion/pop_front.hpp>
+#include <boost/proto/functional/fusion/push_back.hpp>
+#include <boost/proto/functional/fusion/push_front.hpp>
+#include <boost/proto/functional/fusion/reverse.hpp>
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/at.hpp

@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file at.hpp
+/// Proto callables Fusion at
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_AT_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::at() accessor on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::at() accessor on its argument.
+    struct at
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename N>
+        struct result<This(Seq, N)>
+          : fusion::result_of::at<
+                typename boost::remove_reference<Seq>::type
+              , typename boost::remove_const<typename boost::remove_reference<N>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq, N>::type
+        operator ()(Seq &seq, N const & BOOST_PROTO_DISABLE_IF_IS_CONST(Seq)) const
+        {
+            return fusion::at<N>(seq);
+        }
+
+        template<typename Seq, typename N>
+        typename fusion::result_of::at<Seq const, N>::type
+        operator ()(Seq const &seq, N const &) const
+        {
+            return fusion::at<N>(seq);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/pop_back.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file pop_back.hpp
+/// Proto callables Fusion pop_back
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_BACK_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/end.hpp>
+#include <boost/fusion/include/prior.hpp>
+#include <boost/fusion/include/pop_back.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_back() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_back() algorithm on its argument.
+    struct pop_back
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_back<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::pop_back<Seq>::type result_type;
+            return result_type(fusion::begin(seq), fusion::prior(fusion::end(seq)));
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::pop_back<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_back(seq);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/pop_front.hpp

@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file pop_front.hpp
+/// Proto callables Fusion pop_front
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_POP_FRONT_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/begin.hpp>
+#include <boost/fusion/include/end.hpp>
+#include <boost/fusion/include/next.hpp>
+#include <boost/fusion/include/pop_front.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_front() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::pop_front() algorithm on its argument. This is
+    /// useful for defining a CallableTransform like \c pop_front(_)
+    /// which removes the first child from a Proto expression node.
+    /// Such a transform might be used as the first argument to the
+    /// \c proto::fold\<\> transform; that is, fold all but
+    /// the first child.
+    struct pop_front
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::pop_front<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::pop_front<Seq>::type result_type;
+            return result_type(fusion::next(fusion::begin(seq)), fusion::end(seq));
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::pop_front<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::pop_front(seq);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/push_back.hpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file push_back.hpp
+/// Proto callables Fusion push_back
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/push_back.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_back() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_back() algorithm on its argument.
+    struct push_back
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_back<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_back<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_back(seq, t);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/push_front.hpp

@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file push_front.hpp
+/// Proto callables Fusion push_front
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_FRONT_HPP_EAN_11_27_2010
+
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/fusion/include/push_front.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_front() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::push_front() algorithm on its argument.
+    struct push_front
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq, typename T>
+        struct result<This(Seq, T)>
+          : fusion::result_of::push_front<
+                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
+              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
+            >
+        {};
+
+        template<typename Seq, typename T>
+        typename fusion::result_of::push_front<Seq const, T>::type
+        operator ()(Seq const &seq, T const &t) const
+        {
+            return fusion::push_front(seq, t);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/fusion/reverse.hpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file reverse.hpp
+/// Proto callables Fusion reverse
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_FUSION_REVERSE_HPP_EAN_11_27_2010
+
+#include <boost/fusion/include/reverse.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+    /// \brief A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::reverse() algorithm on its argument.
+    ///
+    /// A PolymorphicFunctionObject type that invokes the
+    /// \c fusion::reverse() algorithm on its argument. This is
+    /// useful for defining a CallableTransform like \c reverse(_)
+    /// which reverses the order of the children of a Proto
+    /// expression node.
+    struct reverse
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Seq>
+        struct result<This(Seq)>
+          : result<This(Seq const &)>
+        {};
+
+        template<typename This, typename Seq>
+        struct result<This(Seq &)>
+          : fusion::result_of::reverse<Seq>
+        {};
+
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq>::type
+        operator ()(Seq &seq) const
+        {
+            // Work around a const-correctness issue in Fusion
+            typedef typename fusion::result_of::reverse<Seq>::type result_type;
+            return result_type(seq);
+        }
+
+        template<typename Seq>
+        typename fusion::result_of::reverse<Seq const>::type
+        operator ()(Seq const &seq) const
+        {
+            return fusion::reverse(seq);
+        }
+    };
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range.hpp

@@ -0,0 +1,19 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file range.hpp
+/// Proto callables for things found in the boost range library
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_HPP_EAN_27_08_2012
+
+#include <boost/proto/functional/range/begin.hpp>
+#include <boost/proto/functional/range/empty.hpp>
+#include <boost/proto/functional/range/end.hpp>
+#include <boost/proto/functional/range/rbegin.hpp>
+#include <boost/proto/functional/range/rend.hpp>
+#include <boost/proto/functional/range/size.hpp>
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/begin.hpp

@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file begin.hpp
+/// Proto callables for boost::begin()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_BEGIN_HPP_EAN_27_08_2012
+
+#include <boost/range/begin.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::begin()
+    struct begin
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Rng>
+        struct result<This(Rng)>
+          : boost::range_iterator<Rng const>
+        {};
+
+        template<typename This, typename Rng>
+        struct result<This(Rng &)>
+          : boost::range_iterator<Rng>
+        {};
+
+        template<typename Rng>
+        typename boost::range_iterator<Rng>::type operator()(Rng &rng) const
+        {
+            return boost::begin(rng);
+        }
+
+        template<typename Rng>
+        typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const
+        {
+            return boost::begin(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/empty.hpp

@@ -0,0 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file empty.hpp
+/// Proto callables for boost::empty()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_EMPTY_HPP_EAN_27_08_2012
+
+#include <boost/range/empty.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::empty()
+    struct empty
+    {
+        BOOST_PROTO_CALLABLE()
+
+        typedef bool result_type;
+
+        template<typename Rng>
+        bool operator()(Rng const &rng) const
+        {
+            return boost::empty(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/end.hpp

@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file end.hpp
+/// Proto callables for boost::end()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_END_HPP_EAN_27_08_2012
+
+#include <boost/range/end.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::end()
+    struct end
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Rng>
+        struct result<This(Rng)>
+          : boost::range_iterator<Rng const>
+        {};
+
+        template<typename This, typename Rng>
+        struct result<This(Rng &)>
+          : boost::range_iterator<Rng>
+        {};
+
+        template<typename Rng>
+        typename boost::range_iterator<Rng>::type operator()(Rng &rng) const
+        {
+            return boost::end(rng);
+        }
+
+        template<typename Rng>
+        typename boost::range_iterator<Rng const>::type operator()(Rng const &rng) const
+        {
+            return boost::end(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/rbegin.hpp

@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file rbegin.hpp
+/// Proto callables for boost::rbegin()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_RBEGIN_HPP_EAN_27_08_2012
+
+#include <boost/range/rbegin.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::rbegin()
+    struct rbegin
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Rng>
+        struct result<This(Rng)>
+          : boost::range_reverse_iterator<Rng const>
+        {};
+
+        template<typename This, typename Rng>
+        struct result<This(Rng &)>
+          : boost::range_reverse_iterator<Rng>
+        {};
+
+        template<typename Rng>
+        typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const
+        {
+            return boost::rbegin(rng);
+        }
+
+        template<typename Rng>
+        typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const
+        {
+            return boost::rbegin(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/rend.hpp

@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file rend.hpp
+/// Proto callables for boost::rend()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_REND_HPP_EAN_27_08_2012
+
+#include <boost/range/rend.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::rend()
+    struct rend
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Rng>
+        struct result<This(Rng)>
+          : boost::range_reverse_iterator<Rng const>
+        {};
+
+        template<typename This, typename Rng>
+        struct result<This(Rng &)>
+          : boost::range_reverse_iterator<Rng>
+        {};
+
+        template<typename Rng>
+        typename boost::range_reverse_iterator<Rng>::type operator()(Rng &rng) const
+        {
+            return boost::rend(rng);
+        }
+
+        template<typename Rng>
+        typename boost::range_reverse_iterator<Rng const>::type operator()(Rng const &rng) const
+        {
+            return boost::rend(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/range/size.hpp

@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file size.hpp
+/// Proto callables for boost::size()
+//
+//  Copyright 2012 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012
+#define BOOST_PROTO_FUNCTIONAL_RANGE_SIZE_HPP_EAN_27_08_2012
+
+#include <boost/range/size.hpp>
+#include <boost/proto/proto_fwd.hpp>
+
+namespace boost { namespace proto { namespace functional
+{
+
+    // A PolymorphicFunctionObject that wraps boost::size()
+    struct size
+    {
+        BOOST_PROTO_CALLABLE()
+
+        template<typename Sig>
+        struct result;
+
+        template<typename This, typename Rng>
+        struct result<This(Rng)>
+          : boost::range_size<Rng>
+        {};
+
+        template<typename This, typename Rng>
+        struct result<This(Rng &)>
+          : boost::range_size<Rng>
+        {};
+
+        template<typename Rng>
+        typename boost::range_size<Rng>::type operator()(Rng const &rng) const
+        {
+            return boost::size(rng);
+        }
+    };
+
+}}}
+
+#endif

externals/vcpkg/packages/boost-proto_x64-windows/include/boost/proto/functional/std.hpp

@@ -0,0 +1,15 @@
+///////////////////////////////////////////////////////////////////////////////
+/// \file std.hpp
+/// Proto callables for things found in the std library
+//
+//  Copyright 2010 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)
+
+#ifndef BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010
+#define BOOST_PROTO_FUNCTIONAL_STD_HPP_EAN_11_27_2010
+
+#include <boost/proto/functional/std/utility.hpp>
+#include <boost/proto/functional/std/iterator.hpp>
+
+#endif