stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/auxiliary.hpp

@@ -0,0 +1,16 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ALGORITHM_AUXILIARY_02192011_0907)
+#define FUSION_ALGORITHM_AUXILIARY_02192011_0907
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/auxiliary/copy.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/fusion/algorithm/auxiliary/move.hpp>
+#endif
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/auxiliary/copy.hpp

@@ -0,0 +1,91 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_COPY_02162011_2308)
+#define FUSION_COPY_02162011_2308
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/and.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4100) // unreferenced formal parameter
+#endif
+
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Seq1, typename Seq2>
+        struct sequence_copy
+        {
+            typedef typename result_of::end<Seq1>::type end1_type;
+            typedef typename result_of::end<Seq2>::type end2_type;
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const&, I2 const&, mpl::true_)
+            {
+            }
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const& src, I2 const& dest, mpl::false_)
+            {
+                *dest = *src;
+                call(fusion::next(src), fusion::next(dest));
+            }
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const& src, I2 const& dest)
+            {
+                typename result_of::equal_to<I1, end1_type>::type eq;
+                return call(src, dest, eq);
+            }
+        };
+    }
+
+    namespace result_of
+    {
+        template <typename Seq1, typename Seq2>
+        struct copy
+            : enable_if<mpl::and_<
+                  traits::is_sequence<Seq1>,
+                  traits::is_sequence<Seq2>
+              > > {};
+    }
+
+    template <typename Seq1, typename Seq2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::copy<Seq1 const, Seq2>::type
+    copy(Seq1 const& src, Seq2& dest)
+    {
+        BOOST_STATIC_ASSERT(
+            result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
+
+        detail::sequence_copy<
+            Seq1 const, Seq2>::
+            call(fusion::begin(src), fusion::begin(dest));
+    }
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/auxiliary/move.hpp

@@ -0,0 +1,93 @@
+/*=============================================================================
+    Copyright (c) 2001-2013 Joel de Guzman
+
+    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(FUSION_MOVE_01192013_2225)
+#define FUSION_MOVE_01192013_2225
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/sequence/comparison/detail/equal_to.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/and.hpp>
+
+#include <utility> // for std::move
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4100) // unreferenced formal parameter
+#endif
+
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template <typename Seq1, typename Seq2>
+        struct sequence_move
+        {
+            typedef typename result_of::end<Seq1>::type end1_type;
+            typedef typename result_of::end<Seq2>::type end2_type;
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const&, I2 const&, mpl::true_)
+            {
+            }
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const& src, I2 const& dest, mpl::false_)
+            {
+                *dest = std::move(*src);
+                call(fusion::next(src), fusion::next(dest));
+            }
+
+            template <typename I1, typename I2>
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static void
+            call(I1 const& src, I2 const& dest)
+            {
+                typename result_of::equal_to<I1, end1_type>::type eq;
+                return call(src, dest, eq);
+            }
+        };
+    }
+
+    namespace result_of
+    {
+        template <typename Seq1, typename Seq2>
+        struct move
+            : enable_if<mpl::and_<
+                  traits::is_sequence<Seq1>,
+                  traits::is_sequence<Seq2>
+              > > {};
+    }
+
+    template <typename Seq1, typename Seq2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::move<Seq1, Seq2>::type
+    move(Seq1&& src, Seq2& dest)
+    {
+        BOOST_STATIC_ASSERT(
+            result_of::size<Seq1>::value <= result_of::size<Seq2>::value);
+
+        detail::sequence_move<
+            Seq1, Seq2>::
+            call(fusion::begin(src), fusion::begin(dest));
+    }
+}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration.hpp

@@ -0,0 +1,18 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ALGORITHM_ITERATION_10022005_0549)
+#define FUSION_ALGORITHM_ITERATION_10022005_0549
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/accumulate.hpp>
+#include <boost/fusion/algorithm/iteration/fold.hpp>
+#include <boost/fusion/algorithm/iteration/for_each.hpp>
+#include <boost/fusion/algorithm/iteration/iter_fold.hpp>
+#include <boost/fusion/algorithm/iteration/reverse_fold.hpp>
+#include <boost/fusion/algorithm/iteration/reverse_iter_fold.hpp>
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/accumulate.hpp

@@ -0,0 +1,45 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
+
+    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(FUSION_ACCUMULATE_09172005_1032)
+#define FUSION_ACCUMULATE_09172005_1032
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/accumulate_fwd.hpp>
+#include <boost/fusion/algorithm/iteration/fold.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <typename Sequence, typename State, typename F>
+        struct accumulate
+            : result_of::fold<Sequence, State, F>
+        {};
+    }
+
+    template <typename Sequence, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence, State const, F>::type
+    accumulate(Sequence& seq, State const& state, F f)
+    {
+        return fusion::fold(seq, state, f);
+    }
+
+    template <typename Sequence, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
+    accumulate(Sequence const& seq, State const& state, F f)
+    {
+        return fusion::fold(seq, state, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/accumulate_fwd.hpp

@@ -0,0 +1,33 @@
+/*=============================================================================
+    Copyright (c) 2011 Eric Niebler
+    Copyright (c) 2015 Kohei Takahashi
+
+    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(BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_ACCUMULATE_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename State, typename F>
+        struct accumulate;
+    }
+
+    template <typename Sequence, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence, State const, F>::type
+    accumulate(Sequence& seq, State const& state, F f);
+
+    template <typename Sequence, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::accumulate<Sequence const, State const, F>::type
+    accumulate(Sequence const& seq, State const& state, F f);
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/fold.hpp

@@ -0,0 +1,294 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
+
+    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)
+==============================================================================*/
+#include <boost/preprocessor/cat.hpp>
+
+#define FUSION_HASH #
+
+#ifdef BOOST_FUSION_REVERSE_FOLD
+#   ifdef BOOST_FUSION_ITER_FOLD
+#       define BOOST_FUSION_FOLD_NAME reverse_iter_fold
+#   else
+#       define BOOST_FUSION_FOLD_NAME reverse_fold
+#   endif
+
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION end
+#   define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION prior
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT)                   \
+        typename fusion::result_of::prior<IT>::type
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) fusion::prior(IT)
+#else
+#   ifdef BOOST_FUSION_ITER_FOLD
+#       define BOOST_FUSION_FOLD_NAME iter_fold
+#   else
+#       define BOOST_FUSION_FOLD_NAME fold
+#   endif
+
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION begin
+#   define BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION next
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(IT) IT
+#   define BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(IT) IT
+#endif
+#ifdef BOOST_FUSION_ITER_FOLD
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT) IT&
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) IT
+#else
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(IT)                  \
+        typename fusion::result_of::deref<IT>::type
+#   define BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(IT) fusion::deref(IT)
+#endif
+
+#if (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+FUSION_HASH     define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+FUSION_HASH else
+FUSION_HASH     define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+FUSION_HASH endif
+#else
+#   if BOOST_WORKAROUND(BOOST_MSVC, < 1500)
+#       define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+#   else
+#       define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+#   endif
+#endif
+
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          // Dirty hack: those compilers cannot choose exactly one partial specialization.
+          , bool = SeqSize == 0
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+        >
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)
+        {};
+
+        template<typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          , true
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+          >
+        {
+            typedef typename State::type type;
+        };
+
+        template<int SeqSize, typename It, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, >= 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+                // Following SFINAE enables to avoid MSVC 9's partial specialization
+                // ambiguous bug but MSVC 8 don't compile, and moreover MSVC 8 style
+                // workaround won't work with MSVC 9.
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+#endif
+#else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+            >::type
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH if BOOST_WORKAROUND BOOST_PREVENT_MACRO_SUBSTITUTION (BOOST_MSVC, < 1500)
+#endif
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1500) || \
+    (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
+          , false
+#endif
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+FUSION_HASH endif
+#endif
+          >
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize-1
+              , typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
+                    )
+                >
+              , F
+            >
+        {};
+
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+            0
+          , It
+          , State
+          , F
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                typename result_of::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM(It const)
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION(it)
+              , f(state, BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM(it))
+              , f
+            );
+        }
+
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)
+        {};
+
+        template<typename Seq, typename State, typename F>
+        struct BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F, true, false>
+          : BOOST_PP_CAT(result_of_it_,BOOST_FUSION_FOLD_NAME)<
+                result_of::size<Seq>::value
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<State>
+              , F
+            >
+        {};
+
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>::type
+        BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F& f)
+        {
+            return BOOST_PP_CAT(it_,BOOST_FUSION_FOLD_NAME)<
+                BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM(
+                    typename result_of::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION<Seq>::type
+                )
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM(
+                    fusion::BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION(seq)
+                )
+              , state
+              , f
+            );
+        }
+    }
+
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct BOOST_FUSION_FOLD_NAME
+          : detail::BOOST_PP_CAT(result_of_,BOOST_FUSION_FOLD_NAME)<Seq, State, F>
+        {};
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq& seq, State const& state, F f)
+    {
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State const, F>(seq, state, f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq const
+      , State const
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq const& seq, State const& state, F f)
+    {
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State const, F>(seq, state, f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq
+      , State
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq& seq, State& state, F f)
+    {
+        return detail::BOOST_FUSION_FOLD_NAME<Seq, State, F>(seq, state, f);
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::BOOST_FUSION_FOLD_NAME<
+        Seq const
+      , State
+      , F
+    >::type
+    BOOST_FUSION_FOLD_NAME(Seq const& seq, State& state, F f)
+    {
+        return detail::BOOST_FUSION_FOLD_NAME<Seq const, State, F>(seq, state, f);
+    }
+}}
+
+#undef BOOST_FUSION_FOLD_NAME
+#undef BOOST_FUSION_FOLD_IMPL_ENABLER
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_FUNCTION
+#undef BOOST_FUSION_FOLD_IMPL_NEXT_IT_FUNCTION
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_META_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_FIRST_IT_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_META_TRANSFORM
+#undef BOOST_FUSION_FOLD_IMPL_INVOKE_IT_TRANSFORM
+#undef FUSION_HASH

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/for_each.hpp

@@ -0,0 +1,149 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_FOR_EACH_05052005_1028)
+#define FUSION_FOR_EACH_05052005_1028
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion {
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each_linear(First const&, Last const&, F const&, mpl::true_)
+    {
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each_linear(First const& first, Last const& last, F const& f, mpl::false_)
+    {
+        f(*first);
+        detail::for_each_linear(fusion::next(first), last, f, 
+                                result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each_dispatch(Sequence& seq, F const& f, Tag)
+    {
+        detail::for_each_linear(
+                                fusion::begin(seq)
+                                , fusion::end(seq)
+                                , f
+                                , result_of::equal_to<
+                                typename result_of::begin<Sequence>::type
+                                , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int N>
+    struct for_each_unrolled
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            f(*i2);
+            typedef typename result_of::next<I2>::type I3;
+            I3 i3(fusion::next(i2));
+            f(*i3);
+            for_each_unrolled<N-4>::call(fusion::next(i3), f);
+        }
+    };
+
+    template<>
+    struct for_each_unrolled<3>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            f(*i2);
+        }
+    };
+
+    template<>
+    struct for_each_unrolled<2>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            f(*i1);
+        }
+    };
+
+    template<>
+    struct for_each_unrolled<1>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(I0 const& i0, F const& f)
+        {
+            f(*i0);
+        }
+    };
+
+    template<>
+    struct for_each_unrolled<0>
+    {
+        template<typename It, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static void call(It const&, F const&)
+        {
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each_dispatch(Sequence& seq, F const& f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        for_each_unrolled<result_of::distance<begin, end>::type::value>::call(fusion::begin(seq), f);
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each(Sequence& seq, F const& f, mpl::false_) // unsegmented implementation
+    {
+        detail::for_each_dispatch(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}}
+
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp

@@ -0,0 +1,189 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_fold
+        {};
+        template<typename It, typename State, typename F>
+        struct result_of_it_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
+        {
+            typedef typename State::type type;
+        };
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_fold<
+                SeqSize-1
+              , typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >
+        {};
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_fold<
+            0
+          , It
+          , State
+          , F
+        >::type
+        it_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_fold<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        it_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return it_fold<
+                typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::next(it)
+              , f(state, fusion::deref(it))
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct result_of_fold
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_fold<Seq, State, F, true, false>
+          : result_of_it_fold<
+                result_of::size<Seq>::value
+              , typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >
+        {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_fold<Seq, State, F>::type
+        fold(Seq& seq, State& state, F& f)
+        {
+            return it_fold<
+                typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::begin(seq)
+              , state
+              , f
+            );
+        }
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct fold
+          : detail::result_of_fold<Seq, State, F>
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State const& state, F f)
+    {
+        return detail::fold<Seq, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State const& state, F f)
+    {
+        return detail::fold<Seq const, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq
+      , State
+      , F
+    >::type
+    fold(Seq& seq, State& state, F f)
+    {
+        return detail::fold<Seq, State, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq const
+      , State
+      , F
+    >::type
+    fold(Seq const& seq, State& state, F f)
+    {
+        return detail::fold<Seq const, State, F>(seq, state, f);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp

@@ -0,0 +1,188 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_iter_fold
+        {};
+        template<typename It, typename State, typename F>
+        struct result_of_it_iter_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
+        {
+            typedef typename State::type type;
+        };
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_iter_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_iter_fold<
+                SeqSize-1
+              , typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >
+        {};
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_iter_fold<
+            0
+          , It
+          , State
+          , F
+        >::type
+        it_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_iter_fold<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        it_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return it_iter_fold<
+                typename result_of::next<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::next(it)
+              , f(state, it)
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct result_of_iter_fold
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_iter_fold<Seq, State, F, true, false>
+          : result_of_it_iter_fold<
+                result_of::size<Seq>::value
+              , typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >
+        {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_iter_fold<Seq, State, F>::type
+        iter_fold(Seq& seq, State& state, F& f)
+        {
+            return it_iter_fold<
+                typename result_of::begin<Seq>::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::begin(seq)
+              , state
+              , f
+            );
+        }
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct iter_fold
+          : detail::result_of_iter_fold<Seq, State, F>
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    iter_fold(Seq& seq, State const& state, F f)
+    {
+        return detail::iter_fold<Seq, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    iter_fold(Seq const& seq, State const& state, F f)
+    {
+        return detail::iter_fold<Seq const, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq
+      , State
+      , F
+    >::type
+    iter_fold(Seq& seq, State& state, F f)
+    {
+        return detail::iter_fold<Seq, State, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    iter_fold(Seq const& seq, State& state, F f)
+    {
+        return detail::iter_fold<Seq const, State, F>(seq, state, f);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp

@@ -0,0 +1,188 @@
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_reverse_fold
+        {};
+        template<typename It, typename State, typename F>
+        struct result_of_it_reverse_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
+        {
+            typedef typename State::type type;
+        };
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_reverse_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_reverse_fold<
+                SeqSize-1
+              , typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >
+        {};
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_reverse_fold<
+            0
+          , It
+          , State
+          , F
+        >::type
+        it_reverse_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_reverse_fold<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        it_reverse_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return it_reverse_fold<
+                typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        typename fusion::result_of::deref<It const>::type
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::prior(it)
+              , f(state, fusion::deref(it))
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct result_of_reverse_fold
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_reverse_fold<Seq, State, F, true, false>
+          : result_of_it_reverse_fold<
+                result_of::size<Seq>::value
+              , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >
+        {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_reverse_fold<Seq, State, F>::type
+        reverse_fold(Seq& seq, State& state, F& f)
+        {
+            return it_reverse_fold<
+                typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::prior( fusion::end(seq) )
+              , state
+              , f
+            );
+        }
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_fold
+          : detail::result_of_reverse_fold<Seq, State, F>
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State const& state, F f)
+    {
+        return detail::reverse_fold<Seq, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State const& state, F f)
+    {
+        return detail::reverse_fold<Seq const, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq
+      , State
+      , F
+    >::type
+    reverse_fold(Seq& seq, State& state, F f)
+    {
+        return detail::reverse_fold<Seq, State, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State& state, F f)
+    {
+        return detail::reverse_fold<Seq const, State, F>(seq, state, f);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp

@@ -0,0 +1,188 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) void
+# else
+# define BOOST_FUSION_FOLD_IMPL_ENABLER(T) typename T::type
+# endif
+namespace boost { namespace fusion
+{
+    namespace detail
+    {
+        template<int SeqSize, typename It, typename State, typename F, typename = void
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          
+          , bool = SeqSize == 0
+# endif
+        >
+        struct result_of_it_reverse_iter_fold
+        {};
+        template<typename It, typename State, typename F>
+        struct result_of_it_reverse_iter_fold<0,It,State,F
+          , typename boost::enable_if_has_type<BOOST_FUSION_FOLD_IMPL_ENABLER(State)>::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , true
+# endif
+          >
+        {
+            typedef typename State::type type;
+        };
+        template<int SeqSize, typename It, typename State, typename F>
+        struct result_of_it_reverse_iter_fold<SeqSize,It,State,F
+          , typename boost::enable_if_has_type<
+# if BOOST_WORKAROUND (BOOST_MSVC, >= 1500)
+                
+                
+                
+                typename boost::disable_if_c<SeqSize == 0, State>::type::type
+# else
+                BOOST_FUSION_FOLD_IMPL_ENABLER(State)
+# endif
+            >::type
+# if BOOST_WORKAROUND (BOOST_MSVC, < 1500)
+          , false
+# endif
+          >
+          : result_of_it_reverse_iter_fold<
+                SeqSize-1
+              , typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >
+        {};
+        template<typename It, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_it_reverse_iter_fold<
+            0
+          , It
+          , State
+          , F
+        >::type
+        it_reverse_iter_fold(mpl::int_<0>, It const&, typename State::type state, F&)
+        {
+            return state;
+        }
+        template<typename It, typename State, typename F, int SeqSize>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename lazy_enable_if_c<
+            SeqSize != 0
+          , result_of_it_reverse_iter_fold<
+                SeqSize
+              , It
+              , State
+              , F
+            >
+        >::type
+        it_reverse_iter_fold(mpl::int_<SeqSize>, It const& it, typename State::type state, F& f)
+        {
+            return it_reverse_iter_fold<
+                typename result_of::prior<It>::type
+              , boost::result_of<
+                    F(
+                        typename add_reference<typename State::type>::type,
+                        It const&
+                    )
+                >
+              , F
+            >(
+                mpl::int_<SeqSize-1>()
+              , fusion::prior(it)
+              , f(state, it)
+              , f
+            );
+        }
+        template<typename Seq, typename State, typename F
+          , bool = traits::is_sequence<Seq>::value
+          , bool = traits::is_segmented<Seq>::value>
+        struct result_of_reverse_iter_fold
+        {};
+        template<typename Seq, typename State, typename F>
+        struct result_of_reverse_iter_fold<Seq, State, F, true, false>
+          : result_of_it_reverse_iter_fold<
+                result_of::size<Seq>::value
+              , typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >
+        {};
+        template<typename Seq, typename State, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        inline typename result_of_reverse_iter_fold<Seq, State, F>::type
+        reverse_iter_fold(Seq& seq, State& state, F& f)
+        {
+            return it_reverse_iter_fold<
+                typename fusion::result_of::prior< typename result_of::end<Seq>::type >::type
+              , add_reference<State>
+              , F
+            >(
+                typename result_of::size<Seq>::type()
+              , fusion::prior( fusion::end(seq) )
+              , state
+              , f
+            );
+        }
+    }
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_iter_fold
+          : detail::result_of_reverse_iter_fold<Seq, State, F>
+        {};
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_iter_fold(Seq& seq, State const& state, F f)
+    {
+        return detail::reverse_iter_fold<Seq, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_iter_fold(Seq const& seq, State const& state, F f)
+    {
+        return detail::reverse_iter_fold<Seq const, State const, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq
+      , State
+      , F
+    >::type
+    reverse_iter_fold(Seq& seq, State& state, F f)
+    {
+        return detail::reverse_iter_fold<Seq, State, F>(seq, state, f);
+    }
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    reverse_iter_fold(Seq const& seq, State& state, F f)
+    {
+        return detail::reverse_iter_fold<Seq const, State, F>(seq, state, f);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/segmented_fold.hpp

@@ -0,0 +1,64 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_FOLD_S_HPP_INCLUDED)
+#define BOOST_FUSION_FOLD_S_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Fun>
+    struct segmented_fold_fun
+    {
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        explicit segmented_fold_fun(Fun const& f)
+          : fun(f)
+        {}
+
+        Fun const& fun;
+
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef typename result_of::fold<Sequence, State, Fun>::type type;
+            typedef mpl::true_ continue_type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
+            {
+                return fusion::fold(seq, state, fun.fun);
+            }
+        };
+    };
+
+    // The default implementation of this lives in detail/fold.hpp
+    template <typename Sequence, typename State, typename Fun, bool IsSequence, bool IsSegmented>
+    struct result_of_fold;
+
+    template <typename Sequence, typename State, typename Fun>
+    struct result_of_fold<Sequence, State, Fun, true, true>
+    {
+        typedef
+            typename result_of::segmented_fold_until<
+                Sequence,
+                State,
+                segmented_fold_fun<Fun>
+            >::type
+        type;
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type call(Sequence& seq, State& state, Fun& fun)
+        {
+            return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));
+        }
+    };
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp

@@ -0,0 +1,52 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_FOR_EACH_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FOR_EACH_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/support/void.hpp>
+#include <boost/fusion/algorithm/iteration/for_each_fwd.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Fun>
+    struct segmented_for_each_fun
+    {
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        explicit segmented_for_each_fun(Fun const& f)
+          : fun(f)
+        {}
+
+        Fun const& fun;
+
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef void_ type;
+            typedef mpl::true_ continue_type;
+
+            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const&, Context const&, segmented_for_each_fun const& fun)
+            {
+                fusion::for_each(seq, fun.fun);
+                return void_();
+            }
+        };
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline void
+    for_each(Sequence& seq, F const& f, mpl::true_) // segmented implementation
+    {
+        fusion::segmented_fold_until(seq, void_(), segmented_for_each_fun<F>(f));
+    }
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/fold.hpp

@@ -0,0 +1,59 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2015 Kohei Takahashi
+
+    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_FUSION_ALGORITHM_ITERATION_FOLD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
+#include <boost/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/algorithm/iteration/detail/preprocessed/fold.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/fold.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009-2010 Christopher Schmidt
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+#include <boost/fusion/algorithm/iteration/detail/fold.hpp>
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#include <boost/fusion/algorithm/iteration/detail/segmented_fold.hpp>
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/fold_fwd.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ALGORITHM_ITERATION_FOLD_FWD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_FOLD_FWD_HPP
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct fold;
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq
+      , State const
+      , F
+    >::type
+    fold(Seq& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    fold(Seq const& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq
+      , State
+      , F
+    >::type
+    fold(Seq& seq, State& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::fold<
+        Seq const
+      , State
+      , F
+    >::type
+    fold(Seq const& seq, State& state, F f);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/for_each.hpp

@@ -0,0 +1,54 @@
+/*=============================================================================
+    Copyright (c) 2001-2007 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(BOOST_FUSION_FOR_EACH_20070527_0943)
+#define BOOST_FUSION_FOR_EACH_20070527_0943
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/detail/for_each.hpp>
+#include <boost/fusion/algorithm/iteration/detail/segmented_for_each.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct for_each
+        {
+            typedef void type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence& seq, F const& f)
+    {
+        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence const& seq, F const& f)
+    {
+        detail::for_each(seq, f, typename traits::is_segmented<Sequence>::type());
+    }
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/for_each_fwd.hpp

@@ -0,0 +1,41 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FOR_EACH_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct for_each;
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence& seq, F const& f);
+
+    template <typename Sequence, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , void
+        >::type
+    for_each(Sequence const& seq, F const& f);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/iter_fold.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
+
+    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_FUSION_ALGORITHM_ITERATION_ITER_FOLD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_ITER_FOLD_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/iter_fold_fwd.hpp>
+#include <boost/config.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#define BOOST_FUSION_ITER_FOLD
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/algorithm/iteration/detail/preprocessed/iter_fold.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/iter_fold.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+#include <boost/fusion/algorithm/iteration/detail/fold.hpp>
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#undef BOOST_FUSION_ITER_FOLD
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/iter_fold_fwd.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ALGORITHM_ITERATION_ITER_FOLD_FWD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_ITER_FOLD_FWD_HPP
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct iter_fold;
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    iter_fold(Seq& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    iter_fold(Seq const& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq
+      , State
+      , F
+    >::type
+    iter_fold(Seq& seq, State& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::iter_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    iter_fold(Seq const& seq, State& state, F f);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/reverse_fold.hpp

@@ -0,0 +1,60 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
+
+    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_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp>
+#include <boost/config.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#define BOOST_FUSION_REVERSE_FOLD
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/algorithm/iteration/detail/preprocessed/reverse_fold.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/reverse_fold.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2009-2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+#include <boost/fusion/algorithm/iteration/detail/fold.hpp>
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#undef BOOST_FUSION_REVERSE_FOLD
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/reverse_fold_fwd.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_FWD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_FOLD_FWD_HPP
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_fold;
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq
+      , State
+      , F
+    >::type
+    reverse_fold(Seq& seq, State& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    reverse_fold(Seq const& seq, State& state, F f);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/reverse_iter_fold.hpp

@@ -0,0 +1,61 @@
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2015 Kohei Takahashi
+
+    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_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_HPP
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp>
+#include <boost/config.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/size.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/iterator/prior.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#define BOOST_FUSION_REVERSE_FOLD
+#define BOOST_FUSION_ITER_FOLD
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/algorithm/iteration/detail/preprocessed/reverse_iter_fold.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/reverse_iter_fold.hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2010 Christopher Schmidt
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+#include <boost/fusion/algorithm/iteration/detail/fold.hpp>
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#undef BOOST_FUSION_REVERSE_FOLD
+#undef BOOST_FUSION_ITER_FOLD
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/iteration/reverse_iter_fold_fwd.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+
+#ifndef BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_FWD_HPP
+#define BOOST_FUSION_ALGORITHM_ITERATION_REVERSE_ITER_FOLD_FWD_HPP
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template<typename Seq, typename State, typename F>
+        struct reverse_iter_fold;
+    }
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq
+      , State const
+      , F
+    >::type
+    reverse_iter_fold(Seq& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq const
+      , State const
+      , F
+    >::type
+    reverse_iter_fold(Seq const& seq, State const& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq
+      , State
+      , F
+    >::type
+    reverse_iter_fold(Seq& seq, State& state, F f);
+
+    template<typename Seq, typename State, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::reverse_iter_fold<
+        Seq const
+      , State
+      , F
+    >::type
+    reverse_iter_fold(Seq const& seq, State& state, F f);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query.hpp

@@ -0,0 +1,19 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ALGORITHM_QUERY_10022005_0549)
+#define FUSION_ALGORITHM_QUERY_10022005_0549
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/all.hpp>
+#include <boost/fusion/algorithm/query/any.hpp>
+#include <boost/fusion/algorithm/query/count.hpp>
+#include <boost/fusion/algorithm/query/count_if.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
+#include <boost/fusion/algorithm/query/find_if.hpp>
+#include <boost/fusion/algorithm/query/none.hpp>
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/all.hpp

@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(BOOST_FUSION_ALL_05052005_1238)
+#define BOOST_FUSION_ALL_05052005_1238
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/algorithm/query/detail/all.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct all
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f)
+    {
+        return detail::all(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/any.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005 Eric Niebler
+    Copyright (c) 2007 Dan Marsden
+
+    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(FUSION_ANY_05052005_1230)
+#define FUSION_ANY_05052005_1230
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/algorithm/query/detail/any.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct any
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f)
+    {
+        return detail::any(seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/count.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007
+
+    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(BOOST_FUSION_COUNT_09162005_0150)
+#define BOOST_FUSION_COUNT_09162005_0150
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/count_if.hpp>
+#include <boost/fusion/algorithm/query/detail/count.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct count
+        {
+            typedef int type;
+        };
+    }
+
+    template <typename Sequence, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
+    count(Sequence const& seq, T const& x)
+    {
+        detail::count_compare<T> f(x);
+        return fusion::count_if(seq, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/count_if.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(BOOST_FUSION_COUNT_IF_09162005_0137)
+#define BOOST_FUSION_COUNT_IF_09162005_0137
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/detail/count_if.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct count_if
+        {
+            typedef int type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , int
+        >::type
+    count_if(Sequence const& seq, F f)
+    {
+        return detail::count_if(
+            seq, f, typename traits::category_of<Sequence>::type());
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/all.hpp

@@ -0,0 +1,137 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(FUSION_ALL_05052005_1237)
+#define FUSION_ALL_05052005_1237
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_all(First const&, Last const&, F const&, mpl::true_)
+    {
+        return true;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_all(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        typename result_of::deref<First>::type x = *first;
+        return f(x) &&
+            detail::linear_all(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_all(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int N>
+    struct unrolled_all
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it))&&
+                f(*fusion::advance_c<2>(it)) &&
+                f(*fusion::advance_c<3>(it)) &&
+                detail::unrolled_all<N-4>::call(fusion::advance_c<4>(it), f);
+        }
+    };
+
+    template<>
+    struct unrolled_all<3>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it)) &&
+                f(*fusion::advance_c<2>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_all<2>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) &&
+                f(*fusion::advance_c<1>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_all<1>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return f(*it);
+        }
+    };
+
+    template<>
+    struct unrolled_all<0>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& /*it*/, F /*f*/)
+        {
+            return true;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    all(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_all<result_of::distance<begin, end>::type::value>::call(
+            fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/any.hpp

@@ -0,0 +1,140 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005 Eric Niebler
+    Copyright (c) 2007 Dan Marsden
+
+    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(FUSION_ANY_05052005_1229)
+#define FUSION_ANY_05052005_1229
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_any(First const&, Last const&, F const&, mpl::true_)
+    {
+        return false;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    linear_any(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        typename result_of::deref<First>::type x = *first;
+        return f(x) ||
+            detail::linear_any(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_any(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int N>
+    struct unrolled_any
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it))||
+                f(*fusion::advance_c<2>(it)) ||
+                f(*fusion::advance_c<3>(it)) ||
+                detail::unrolled_any<N-4>::call(fusion::advance_c<4>(it), f);
+        }
+    };
+
+    template<>
+    struct unrolled_any<3>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it)) ||
+                f(*fusion::advance_c<2>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_any<2>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return
+                f(*it) ||
+                f(*fusion::advance_c<1>(it));
+        }
+    };
+
+    template<>
+    struct unrolled_any<1>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const& it, F f)
+        {
+            return f(*it);
+        }
+    };
+
+    template<>
+    struct unrolled_any<0>
+    {
+        template <typename It, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool call(It const&, F)
+        {
+            return false;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    any(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_any<result_of::distance<begin, end>::type::value>::call(
+            fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/count.hpp

@@ -0,0 +1,83 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_COUNT_09162005_0158)
+#define FUSION_COUNT_09162005_0158
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/config.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/fusion/support/detail/access.hpp>
+
+#if defined (BOOST_MSVC)
+#  pragma warning(push)
+#  pragma warning (disable: 4512) // assignment operator could not be generated.
+#endif
+
+namespace boost { namespace fusion { namespace detail
+{ 
+    template <bool is_convertible>
+    struct compare_convertible;
+
+    // T1 is convertible to T2 or vice versa
+    template <>
+    struct compare_convertible<true>
+    {
+        template <typename T1, typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool
+        call(T1 const& x, T2 const& y)
+        {
+            return x == y;
+        }
+    };
+
+    // T1 is NOT convertible to T2 NOR vice versa
+    template <>
+    struct compare_convertible<false>
+    {
+        template <typename T1, typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static bool
+        call(T1 const&, T2 const&)
+        {
+            return false;
+        }
+    };
+
+    template <typename T1>
+    struct count_compare
+    {
+        typedef typename detail::call_param<T1>::type param;
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        count_compare(param in_x)
+            : x(in_x) {}
+
+        template <typename T2>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        bool
+        operator()(T2 const& y) const
+        {
+            return
+                compare_convertible<
+                    mpl::or_<
+                        is_convertible<T1, T2>
+                      , is_convertible<T2, T1> 
+                    >::value
+                >::call(x, y);
+        }
+
+        param x;
+    };
+}}}
+
+#if defined (BOOST_MSVC)
+#  pragma warning(pop)
+#endif
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/count_if.hpp

@@ -0,0 +1,180 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(BOOST_FUSION_COUNT_IF_09162005_0141)
+#define BOOST_FUSION_COUNT_IF_09162005_0141
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/iterator/deref.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename First, typename Last, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    linear_count_if(First const&, Last const&, F const&, mpl::true_)
+    {
+        return 0;
+    }
+
+    template <typename First, typename Last, typename F>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    linear_count_if(First const& first, Last const& last, F& f, mpl::false_)
+    {
+        int n =
+            detail::linear_count_if(
+                fusion::next(first)
+              , last
+              , f
+              , result_of::equal_to<typename result_of::next<First>::type, Last>());
+        if (f(*first))
+            ++n;
+        return n;
+    }
+
+    template <typename Sequence, typename F, typename Tag>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    count_if(Sequence const& seq, F f, Tag)
+    {
+        return detail::linear_count_if(
+                fusion::begin(seq)
+              , fusion::end(seq)
+              , f
+              , result_of::equal_to<
+                    typename result_of::begin<Sequence>::type
+                  , typename result_of::end<Sequence>::type>());
+    }
+
+    template<int n>
+    struct unrolled_count_if
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = unrolled_count_if<n-4>::
+                call(fusion::advance_c<4>(i0), f);
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            if(f(*i2))
+                ++ct;
+
+            typedef typename result_of::next<I2>::type I3;
+            I3 i3(fusion::next(i2));
+            if(f(*i3))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<3>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            typedef typename result_of::next<I1>::type I2;
+            I2 i2(fusion::next(i1));
+            if(f(*i2))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<2>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+
+            if(f(*i0))
+                ++ct;
+
+            typedef typename result_of::next<I0>::type I1;
+            I1 i1(fusion::next(i0));
+            if(f(*i1))
+                ++ct;
+
+            return ct;
+        }
+    };
+
+    template<>
+    struct unrolled_count_if<1>
+    {
+        template<typename I0, typename F>
+        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const& i0, F f)
+        {
+            int ct = 0;
+            if(f(*i0))
+                ++ct;
+            return ct;
+        }
+    };
+
+
+    template<>
+    struct unrolled_count_if<0>
+    {
+        template<typename I0, typename F>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static int call(I0 const&, F)
+        {
+            return 0;
+        }
+    };
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline int
+    count_if(Sequence const& seq, F f, random_access_traversal_tag)
+    {
+        typedef typename result_of::begin<Sequence>::type begin;
+        typedef typename result_of::end<Sequence>::type end;
+        return detail::unrolled_count_if<result_of::distance<begin, end>::type::value>::
+            call(fusion::begin(seq), f);
+    }
+}}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/find_if.hpp

@@ -0,0 +1,260 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+    Copyright (c) 2009 Christopher Schmidt
+
+    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(FUSION_FIND_IF_05052005_1107)
+#define FUSION_FIND_IF_05052005_1107
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/fusion/iterator/advance.hpp>
+#include <boost/fusion/iterator/distance.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/category_of.hpp>
+
+namespace boost { namespace fusion { 
+    struct random_access_traversal_tag;
+namespace detail
+{
+    template <typename Iterator, typename Pred>
+    struct apply_filter
+    {
+        typedef typename mpl::apply1<
+            Pred, Iterator>::type type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if;
+
+    template <typename First, typename Last, typename Pred>
+    struct recursive_find_if
+    {
+        typedef typename
+            main_find_if<
+                typename result_of::next<First>::type, Last, Pred
+            >::type
+        type;
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct main_find_if
+    {
+        typedef mpl::or_<
+            result_of::equal_to<First, Last>
+          , apply_filter<First, Pred> >
+        filter;
+
+        typedef typename
+            mpl::eval_if<
+                filter
+              , mpl::identity<First>
+              , recursive_find_if<First, Last, Pred>
+            >::type
+        type;
+    };
+
+    template<
+        typename First, typename Last, 
+        typename Pred, bool>
+    struct choose_find_if;
+
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, false>
+        : main_find_if<First, Last, Pred>
+    {};
+
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again;
+
+    template <typename Iter, typename Pred, int offset>
+    struct apply_offset_filter
+    {
+        typedef typename result_of::advance_c<Iter, offset>::type Shifted;
+        typedef typename
+            mpl::apply1<
+                Pred
+              , Shifted
+            >::type
+        type;
+        BOOST_STATIC_CONSTANT(int, value = type::value);
+    };
+
+    template<typename Iter, typename Pred, int n>
+    struct unrolled_find_if
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                mpl::eval_if<
+                  apply_offset_filter<Iter, Pred, 3>,
+                  result_of::advance_c<Iter, 3>,
+                  unroll_again<
+                    Iter,
+                    Pred,
+                    n,
+                    4> > > > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 3>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              mpl::eval_if<
+                apply_offset_filter<Iter, Pred, 2>,
+                result_of::advance_c<Iter, 2>,
+                result_of::advance_c<Iter, 3> > > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 2>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            mpl::eval_if<
+              apply_offset_filter<Iter, Pred, 1>,
+              result_of::advance_c<Iter, 1>,
+              result_of::advance_c<Iter, 2> > >::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 1>
+    {
+        typedef typename mpl::eval_if<
+            apply_filter<Iter, Pred>,
+            mpl::identity<Iter>,
+            result_of::advance_c<Iter, 1> >::type type;
+    };
+
+    template<typename Iter, typename Pred, int n, int unrolling>
+    struct unroll_again
+    {
+        typedef typename unrolled_find_if<
+            typename result_of::advance_c<Iter, unrolling>::type,
+            Pred,
+            n-unrolling>::type type;
+    };
+
+    template<typename Iter, typename Pred>
+    struct unrolled_find_if<Iter, Pred, 0>
+    {
+        typedef Iter type;
+    };
+
+    template<typename First, typename Last, typename Pred>
+    struct choose_find_if<First, Last, Pred, true>
+    {
+        typedef typename result_of::distance<First, Last>::type N;
+        typedef typename unrolled_find_if<First, Pred, N::value>::type type;
+    };
+
+    template <typename First, typename Last, typename Pred>
+    struct static_find_if
+    {
+        typedef typename
+            choose_find_if<
+                First
+              , Last
+              , typename mpl::lambda<Pred>::type
+              , is_base_of<random_access_traversal_tag, typename traits::category_of<First>::type>::value
+            >::type
+        type;
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter, mpl::true_)
+        {
+            return iter;
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter, mpl::false_)
+        {
+            return recursive_call(fusion::next(iter));
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        recursive_call(Iterator const& iter)
+        {
+            typedef result_of::equal_to<Iterator, type> found;
+            return recursive_call(iter, found());
+        }
+
+        template <typename Iterator, typename Tag>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        choose_call(Iterator const& iter, Tag)
+        {
+            return recursive_call(iter);
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        choose_call(Iterator const& iter, random_access_traversal_tag)
+        {
+            typedef typename result_of::distance<Iterator, type>::type N;
+            return fusion::advance<N>(iter);
+        }
+
+        template <typename Iterator>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        iter_call(Iterator const& iter)
+        {
+            return choose_call(iter, typename traits::category_of<Iterator>::type());
+        }
+
+        template <typename Sequence>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static type
+        call(Sequence& seq)
+        {
+            return iter_call(fusion::begin(seq));
+        }
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_find_if
+    {
+        typedef
+            static_find_if<
+                typename result_of::begin<Sequence>::type
+              , typename result_of::end<Sequence>::type
+              , Pred
+            >
+        filter;
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/segmented_find.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/algorithm/query/find_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename T>
+    struct segmented_find_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                typename result_of::find<Sequence, T>::type
+            iterator_type;
+
+            typedef
+                typename result_of::equal_to<
+                    iterator_type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            continue_type;
+
+            typedef
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_fun)
+            {
+                return call_impl(seq, state, context, continue_type());
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
+            {
+                return state;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_)
+            {
+                return fusion::make_segmented_iterator(fusion::find<T>(seq), context);
+            }
+        };
+    };
+
+    template <typename Sequence, typename T>
+    struct result_of_segmented_find
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_fun<T>
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , detail::segmented_find_fun<T>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/detail/segmented_find_if.hpp

@@ -0,0 +1,95 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED)
+#define BOOST_FUSION_SEGMENTED_FIND_IF_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/support/segmented_fold_until.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Pred>
+    struct segmented_find_if_fun
+    {
+        template <typename Sequence, typename State, typename Context>
+        struct apply
+        {
+            typedef
+                typename result_of::find_if<Sequence, Pred>::type
+            iterator_type;
+
+            typedef
+                typename result_of::equal_to<
+                    iterator_type
+                  , typename result_of::end<Sequence>::type
+                >::type
+            continue_type;
+
+            typedef
+                typename mpl::eval_if<
+                    continue_type
+                  , mpl::identity<State>
+                  , result_of::make_segmented_iterator<
+                        iterator_type
+                      , Context
+                    >
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq, State const&state, Context const& context, segmented_find_if_fun)
+            {
+                return call_impl(seq, state, context, continue_type());
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence&, State const&state, Context const&, mpl::true_)
+            {
+                return state;
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call_impl(Sequence& seq, State const&, Context const& context, mpl::false_)
+            {
+                return fusion::make_segmented_iterator(fusion::find_if<Pred>(seq), context);
+            }
+        };
+    };
+
+    template <typename Sequence, typename Pred>
+    struct result_of_segmented_find_if
+    {
+        struct filter
+        {
+            typedef
+                typename result_of::segmented_fold_until<
+                    Sequence
+                  , typename result_of::end<Sequence>::type
+                  , segmented_find_if_fun<Pred>
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type call(Sequence& seq)
+            {
+                return fusion::segmented_fold_until(
+                    seq
+                  , fusion::end(seq)
+                  , segmented_find_if_fun<Pred>());
+            }
+        };
+
+        typedef typename filter::type type;
+    };
+}}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/find.hpp

@@ -0,0 +1,72 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(FUSION_FIND_05052005_1107)
+#define FUSION_FIND_05052005_1107
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/algorithm/query/detail/find_if.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find.hpp>
+#include <boost/fusion/iterator/key_of.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/support/category_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find<Sequence, T>
+              , detail::result_of_find_if<
+                    Sequence,
+                    is_same<
+                        typename mpl::if_<
+                            traits::is_associative<Sequence>
+                          , key_of<mpl::_1>
+                          , value_of<mpl::_1>
+                        >::type
+                      , T
+                    >
+                >
+            >::type
+        {};
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq)
+    {
+        typedef typename result_of::find<Sequence, T>::filter filter;
+        return filter::call(seq);
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq)
+    {
+        typedef typename result_of::find<Sequence const, T>::filter filter;
+        return filter::call(seq);
+    }
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/find_fwd.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_FIND_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct find;
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find<Sequence, T>
+        >::type const
+    find(Sequence& seq);
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find<Sequence const, T>::type const
+    find(Sequence const& seq);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/find_if.hpp

@@ -0,0 +1,67 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(FUSION_FIND_IF_05052005_1108)
+#define FUSION_FIND_IF_05052005_1108
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/find_if_fwd.hpp>
+#include <boost/fusion/algorithm/query/detail/find_if.hpp>
+#include <boost/fusion/algorithm/query/detail/segmented_find_if.hpp>
+#include <boost/fusion/iterator/value_of.hpp>
+#include <boost/fusion/support/is_segmented.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/lambda.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/quote.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if
+          : mpl::if_<
+                traits::is_segmented<Sequence>
+              , detail::result_of_segmented_find_if<Sequence, Pred>
+              , detail::result_of_find_if<
+                    Sequence,
+                    mpl::bind1<
+                        typename mpl::lambda<Pred>::type
+                      , mpl::bind1<mpl::quote1<value_of>, mpl::_1>
+                    >
+                >
+            >::type
+        {};
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq)
+    {
+        typedef typename result_of::find_if<Sequence, Pred>::filter filter;
+        return filter::call(seq);
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq)
+    {
+        typedef typename result_of::find_if<Sequence const, Pred>::filter filter;
+        return filter::call(seq);
+    }
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/find_if_fwd.hpp

@@ -0,0 +1,38 @@
+/*=============================================================================
+    Copyright (c) 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)
+==============================================================================*/
+#if !defined(BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED)
+#define BOOST_FUSION_FIND_IF_FWD_HPP_INCLUDED
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+// Forward declaration of find_if algorithm
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct find_if;
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_disable_if<
+            is_const<Sequence>
+          , result_of::find_if<Sequence, Pred>
+        >::type
+    find_if(Sequence& seq);
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::find_if<Sequence const, Pred>::type const
+    find_if(Sequence const& seq);
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/query/none.hpp

@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2007 Dan Marsden
+
+    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(BOOST_FUSION_NONE_07062005_1128)
+#define BOOST_FUSION_NONE_07062005_1128
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/any.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F>
+        struct none
+        {
+            typedef bool type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline bool
+    none(Sequence const& seq, F f)
+    {
+        return !fusion::any(seq, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation.hpp

@@ -0,0 +1,32 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ALGORITHM_TRANSFORMATION_10022005_0551)
+#define FUSION_ALGORITHM_TRANSFORMATION_10022005_0551
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/transformation/clear.hpp>
+#include <boost/fusion/algorithm/transformation/erase.hpp>
+#include <boost/fusion/algorithm/transformation/erase_key.hpp>
+#include <boost/fusion/algorithm/transformation/filter.hpp>
+#include <boost/fusion/algorithm/transformation/filter_if.hpp>
+#include <boost/fusion/algorithm/transformation/insert.hpp>
+#include <boost/fusion/algorithm/transformation/insert_range.hpp>
+#include <boost/fusion/algorithm/transformation/join.hpp> 
+#include <boost/fusion/algorithm/transformation/pop_back.hpp>
+#include <boost/fusion/algorithm/transformation/pop_front.hpp>
+#include <boost/fusion/algorithm/transformation/push_back.hpp>
+#include <boost/fusion/algorithm/transformation/push_front.hpp>
+#include <boost/fusion/algorithm/transformation/remove.hpp>
+#include <boost/fusion/algorithm/transformation/remove_if.hpp>
+#include <boost/fusion/algorithm/transformation/replace.hpp>
+#include <boost/fusion/algorithm/transformation/replace_if.hpp>
+#include <boost/fusion/algorithm/transformation/reverse.hpp>
+#include <boost/fusion/algorithm/transformation/transform.hpp>
+#include <boost/fusion/algorithm/transformation/zip.hpp>
+#include <boost/fusion/algorithm/transformation/flatten.hpp>
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/clear.hpp

@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_CLEAR_09172005_1127)
+#define FUSION_CLEAR_09172005_1127
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/container/vector/vector10.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct clear
+        {
+            typedef vector0<> type;
+        };
+    }
+
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::clear<Sequence const>::type
+    clear(Sequence const& /*seq*/)
+    {
+        return vector0<>();
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/preprocessed/zip.hpp

@@ -0,0 +1,22 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if FUSION_MAX_ZIP_SEQUENCES <= 10
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip10.hpp>
+#elif FUSION_MAX_ZIP_SEQUENCES <= 20
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip20.hpp>
+#elif FUSION_MAX_ZIP_SEQUENCES <= 30
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip30.hpp>
+#elif FUSION_MAX_ZIP_SEQUENCES <= 40
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip40.hpp>
+#elif FUSION_MAX_ZIP_SEQUENCES <= 50
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip50.hpp>
+#else
+#error "FUSION_MAX_ZIP_SEQUENCES out of bounds for preprocessed headers"
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/preprocessed/zip10.hpp

@@ -0,0 +1,216 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template<typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ , typename T10 = fusion::void_>
+        struct zip;
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 >
+        struct zip< T0 , T1
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1>::type
+    zip(T0 const& t0 , T1 const& t1)
+    {
+        fusion::vector<const T0& , const T1&> seqs(
+            t0 , t1);
+        return typename result_of::zip<const T0 , const T1>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 >
+        struct zip< T0 , T1 , T2
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2)
+    {
+        fusion::vector<const T0& , const T1& , const T2&> seqs(
+            t0 , t1 , t2);
+        return typename result_of::zip<const T0 , const T1 , const T2>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 >
+        struct zip< T0 , T1 , T2 , T3
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3&> seqs(
+            t0 , t1 , t2 , t3);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+        struct zip< T0 , T1 , T2 , T3 , T4
+                    , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4&> seqs(
+            t0 , t1 , t2 , t3 , t4);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5
+                    , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6
+                    , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                    , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                    , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                    , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type(
+            seqs);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/preprocessed/zip20.hpp

@@ -0,0 +1,436 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template<typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ , typename T10 = fusion::void_ , typename T11 = fusion::void_ , typename T12 = fusion::void_ , typename T13 = fusion::void_ , typename T14 = fusion::void_ , typename T15 = fusion::void_ , typename T16 = fusion::void_ , typename T17 = fusion::void_ , typename T18 = fusion::void_ , typename T19 = fusion::void_ , typename T20 = fusion::void_>
+        struct zip;
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 >
+        struct zip< T0 , T1
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1>::type
+    zip(T0 const& t0 , T1 const& t1)
+    {
+        fusion::vector<const T0& , const T1&> seqs(
+            t0 , t1);
+        return typename result_of::zip<const T0 , const T1>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 >
+        struct zip< T0 , T1 , T2
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2)
+    {
+        fusion::vector<const T0& , const T1& , const T2&> seqs(
+            t0 , t1 , t2);
+        return typename result_of::zip<const T0 , const T1 , const T2>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 >
+        struct zip< T0 , T1 , T2 , T3
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3&> seqs(
+            t0 , t1 , t2 , t3);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+        struct zip< T0 , T1 , T2 , T3 , T4
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4&> seqs(
+            t0 , t1 , t2 , t3 , t4);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+                    , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
+                    , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16
+                    , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17
+                    , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18
+                    , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+                    , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type(
+            seqs);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/preprocessed/zip30.hpp

@@ -0,0 +1,656 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template<typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ , typename T10 = fusion::void_ , typename T11 = fusion::void_ , typename T12 = fusion::void_ , typename T13 = fusion::void_ , typename T14 = fusion::void_ , typename T15 = fusion::void_ , typename T16 = fusion::void_ , typename T17 = fusion::void_ , typename T18 = fusion::void_ , typename T19 = fusion::void_ , typename T20 = fusion::void_ , typename T21 = fusion::void_ , typename T22 = fusion::void_ , typename T23 = fusion::void_ , typename T24 = fusion::void_ , typename T25 = fusion::void_ , typename T26 = fusion::void_ , typename T27 = fusion::void_ , typename T28 = fusion::void_ , typename T29 = fusion::void_ , typename T30 = fusion::void_>
+        struct zip;
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 >
+        struct zip< T0 , T1
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1>::type
+    zip(T0 const& t0 , T1 const& t1)
+    {
+        fusion::vector<const T0& , const T1&> seqs(
+            t0 , t1);
+        return typename result_of::zip<const T0 , const T1>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 >
+        struct zip< T0 , T1 , T2
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2)
+    {
+        fusion::vector<const T0& , const T1& , const T2&> seqs(
+            t0 , t1 , t2);
+        return typename result_of::zip<const T0 , const T1 , const T2>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 >
+        struct zip< T0 , T1 , T2 , T3
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3&> seqs(
+            t0 , t1 , t2 , t3);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+        struct zip< T0 , T1 , T2 , T3 , T4
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4&> seqs(
+            t0 , t1 , t2 , t3 , t4);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24
+                    , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25
+                    , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26
+                    , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27
+                    , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28
+                    , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29
+                    , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29>::type(
+            seqs);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/preprocessed/zip40.hpp

@@ -0,0 +1,876 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+namespace boost { namespace fusion
+{
+    struct void_;
+    namespace result_of
+    {
+        template<typename T0 = fusion::void_ , typename T1 = fusion::void_ , typename T2 = fusion::void_ , typename T3 = fusion::void_ , typename T4 = fusion::void_ , typename T5 = fusion::void_ , typename T6 = fusion::void_ , typename T7 = fusion::void_ , typename T8 = fusion::void_ , typename T9 = fusion::void_ , typename T10 = fusion::void_ , typename T11 = fusion::void_ , typename T12 = fusion::void_ , typename T13 = fusion::void_ , typename T14 = fusion::void_ , typename T15 = fusion::void_ , typename T16 = fusion::void_ , typename T17 = fusion::void_ , typename T18 = fusion::void_ , typename T19 = fusion::void_ , typename T20 = fusion::void_ , typename T21 = fusion::void_ , typename T22 = fusion::void_ , typename T23 = fusion::void_ , typename T24 = fusion::void_ , typename T25 = fusion::void_ , typename T26 = fusion::void_ , typename T27 = fusion::void_ , typename T28 = fusion::void_ , typename T29 = fusion::void_ , typename T30 = fusion::void_ , typename T31 = fusion::void_ , typename T32 = fusion::void_ , typename T33 = fusion::void_ , typename T34 = fusion::void_ , typename T35 = fusion::void_ , typename T36 = fusion::void_ , typename T37 = fusion::void_ , typename T38 = fusion::void_ , typename T39 = fusion::void_ , typename T40 = fusion::void_>
+        struct zip;
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 >
+        struct zip< T0 , T1
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1>::type
+    zip(T0 const& t0 , T1 const& t1)
+    {
+        fusion::vector<const T0& , const T1&> seqs(
+            t0 , t1);
+        return typename result_of::zip<const T0 , const T1>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 >
+        struct zip< T0 , T1 , T2
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2)
+    {
+        fusion::vector<const T0& , const T1& , const T2&> seqs(
+            t0 , t1 , t2);
+        return typename result_of::zip<const T0 , const T1 , const T2>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 >
+        struct zip< T0 , T1 , T2 , T3
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3&> seqs(
+            t0 , t1 , t2 , t3);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+        struct zip< T0 , T1 , T2 , T3 , T4
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4&> seqs(
+            t0 , t1 , t2 , t3 , t4);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33
+                    , void_ , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34
+                    , void_ , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35
+                    , void_ , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34 , T35 const& t35)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34& , const T35&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34 , t35);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36
+                    , void_ , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34 , T35 const& t35 , T36 const& t36)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34& , const T35& , const T36&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34 , t35 , t36);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37
+                    , void_ , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34 , T35 const& t35 , T36 const& t36 , T37 const& t37)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34& , const T35& , const T36& , const T37&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34 , t35 , t36 , t37);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38
+                    , void_ , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37 , const T38>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34 , T35 const& t35 , T36 const& t36 , T37 const& t37 , T38 const& t38)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34& , const T35& , const T36& , const T37& , const T38&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34 , t35 , t36 , t37 , t38);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37 , const T38>::type(
+            seqs);
+    }
+    namespace result_of
+    {
+        template< typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 >
+        struct zip< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39
+                    , void_
+        >
+        {
+            typedef mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+    template<typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37 , const T38 , const T39>::type
+    zip(T0 const& t0 , T1 const& t1 , T2 const& t2 , T3 const& t3 , T4 const& t4 , T5 const& t5 , T6 const& t6 , T7 const& t7 , T8 const& t8 , T9 const& t9 , T10 const& t10 , T11 const& t11 , T12 const& t12 , T13 const& t13 , T14 const& t14 , T15 const& t15 , T16 const& t16 , T17 const& t17 , T18 const& t18 , T19 const& t19 , T20 const& t20 , T21 const& t21 , T22 const& t22 , T23 const& t23 , T24 const& t24 , T25 const& t25 , T26 const& t26 , T27 const& t27 , T28 const& t28 , T29 const& t29 , T30 const& t30 , T31 const& t31 , T32 const& t32 , T33 const& t33 , T34 const& t34 , T35 const& t35 , T36 const& t36 , T37 const& t37 , T38 const& t38 , T39 const& t39)
+    {
+        fusion::vector<const T0& , const T1& , const T2& , const T3& , const T4& , const T5& , const T6& , const T7& , const T8& , const T9& , const T10& , const T11& , const T12& , const T13& , const T14& , const T15& , const T16& , const T17& , const T18& , const T19& , const T20& , const T21& , const T22& , const T23& , const T24& , const T25& , const T26& , const T27& , const T28& , const T29& , const T30& , const T31& , const T32& , const T33& , const T34& , const T35& , const T36& , const T37& , const T38& , const T39&> seqs(
+            t0 , t1 , t2 , t3 , t4 , t5 , t6 , t7 , t8 , t9 , t10 , t11 , t12 , t13 , t14 , t15 , t16 , t17 , t18 , t19 , t20 , t21 , t22 , t23 , t24 , t25 , t26 , t27 , t28 , t29 , t30 , t31 , t32 , t33 , t34 , t35 , t36 , t37 , t38 , t39);
+        return typename result_of::zip<const T0 , const T1 , const T2 , const T3 , const T4 , const T5 , const T6 , const T7 , const T8 , const T9 , const T10 , const T11 , const T12 , const T13 , const T14 , const T15 , const T16 , const T17 , const T18 , const T19 , const T20 , const T21 , const T22 , const T23 , const T24 , const T25 , const T26 , const T27 , const T28 , const T29 , const T30 , const T31 , const T32 , const T33 , const T34 , const T35 , const T36 , const T37 , const T38 , const T39>::type(
+            seqs);
+    }
+}}

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/replace.hpp

@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REPLACE_08182005_0841)
+#define FUSION_REPLACE_08182005_0841
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <bool is_convertible>
+    struct replacer_helper;
+
+    template <>
+    struct replacer_helper<false>
+    {
+        template <typename U, typename T>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static U&
+        call(U& x, T const&, T const&)
+        {
+            return x;
+        }
+    };
+
+    template <>
+    struct replacer_helper<true>
+    {
+        template <typename U, typename T>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static U
+        call(U& x, T const& old_value, T const& new_value)
+        {
+            return (x == old_value) ? new_value : x;
+        }
+    };
+
+    template <typename T>
+    struct replacer
+    {
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        replacer(T const& in_old_value, T const& in_new_value)
+            : old_value(in_old_value), new_value(in_new_value) {}
+
+        template<typename Sig>
+        struct result;
+
+        template <typename U1, typename U2>
+        struct result<replacer<U1>(U2)>
+        {
+            typedef typename remove_reference<U2>::type value;
+            typedef typename
+                mpl::if_<is_convertible<T, value>, value, value const&>::type
+            type;
+        };
+
+        template <typename U>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        typename result<replacer(U)>::type
+        operator()(U const& x) const
+        {
+            return replacer_helper<is_convertible<T, U>::value>::
+                call(x, old_value, new_value);
+        }
+
+        T old_value;
+        T new_value;
+    };
+}}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/detail/replace_if.hpp

@@ -0,0 +1,78 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REPLACE_IF_08182005_0946)
+#define FUSION_REPLACE_IF_08182005_0946
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <bool is_convertible>
+    struct replacer_if_helper;
+
+    template <>
+    struct replacer_if_helper<false>
+    {
+        template <typename U, typename F, typename T>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static U&
+        call(U& x, F&, T const&)
+        {
+            return x;
+        }
+    };
+
+    template <>
+    struct replacer_if_helper<true>
+    {
+        template <typename U, typename F, typename T>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        static U
+        call(U& x, F& f, T const& new_value)
+        {
+            return f(x) ? new_value : x;
+        }
+    };
+
+    template <typename F, typename T>
+    struct replacer_if
+    {
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        replacer_if(F in_f, T const& in_new_value)
+            : f(in_f), new_value(in_new_value) {}
+
+        template<typename Params>
+        struct result;
+
+        template <typename F1, typename T1, typename U>
+        struct result<replacer_if<F1, T1>(U)>
+        {
+            typedef typename remove_reference<U>::type value;
+            typedef typename
+                mpl::if_<is_convertible<T, value>, value, value const&>::type
+            type;
+        };
+
+        template <typename U>
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        typename result<replacer_if(U)>::type
+        operator()(U const& x) const
+        {
+            return replacer_if_helper<is_convertible<T, U>::value>::
+                call(x, f, new_value);
+        }
+
+        F f;
+        T new_value;
+    };
+}}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/erase.hpp

@@ -0,0 +1,140 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ERASE_07232005_0534)
+#define FUSION_ERASE_07232005_0534
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/iterator/equal_to.hpp>
+#include <boost/fusion/iterator/mpl/convert_iterator.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename First>
+        struct compute_erase_last // put this in detail!!!
+        {
+            typedef typename result_of::end<Sequence>::type seq_last_type;
+            typedef typename convert_iterator<First>::type first_type;
+            typedef typename
+                mpl::if_<
+                    result_of::equal_to<first_type, seq_last_type>
+                  , first_type
+                  , typename result_of::next<first_type>::type
+                >::type
+            type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(First const& first, mpl::false_)
+            {
+                return fusion::next(convert_iterator<First>::call(first));
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(First const& first, mpl::true_)
+            {
+                return convert_iterator<First>::call(first);
+            }
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(First const& first)
+            {
+                return call(first, result_of::equal_to<first_type, seq_last_type>());
+            }
+        };
+
+        struct use_default;
+
+        template <class T, class Default>
+        struct fusion_default_help
+          : mpl::if_<
+                is_same<T, use_default>
+              , Default
+              , T
+            >
+        {
+        };
+
+        template <
+            typename Sequence
+          , typename First
+          , typename Last = use_default>
+        struct erase
+        {
+            typedef typename result_of::begin<Sequence>::type seq_first_type;
+            typedef typename result_of::end<Sequence>::type seq_last_type;
+            BOOST_STATIC_ASSERT((!result_of::equal_to<seq_first_type, seq_last_type>::value));
+
+            typedef First FirstType;
+            typedef typename 
+                fusion_default_help<
+                    Last 
+                  , typename compute_erase_last<Sequence, First>::type
+                >::type
+            LastType;
+
+            typedef typename convert_iterator<FirstType>::type first_type;
+            typedef typename convert_iterator<LastType>::type last_type;
+            typedef iterator_range<seq_first_type, first_type> left_type;
+            typedef iterator_range<last_type, seq_last_type> right_type;
+            typedef joint_view<left_type, right_type> type;
+        };
+    }
+
+    template <typename Sequence, typename First>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , typename result_of::erase<Sequence const, First> 
+        >::type
+    erase(Sequence const& seq, First const& first)
+    {
+        typedef result_of::erase<Sequence const, First> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::type result_type;
+
+        left_type left(
+            fusion::begin(seq)
+          , convert_iterator<First>::call(first));
+        right_type right(
+            fusion::result_of::compute_erase_last<Sequence const, First>::call(first)
+          , fusion::end(seq));
+        return result_type(left, right);
+    }
+
+    template <typename Sequence, typename First, typename Last>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::erase<Sequence const, First, Last>::type
+    erase(Sequence const& seq, First const& first, Last const& last)
+    {
+        typedef result_of::erase<Sequence const, First, Last> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::type result_type;
+
+        left_type left(fusion::begin(seq), first);
+        right_type right(last, fusion::end(seq));
+        return result_type(left, right);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/erase_key.hpp

@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_ERASE_KEY_10022005_1851)
+#define FUSION_ERASE_KEY_10022005_1851
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/algorithm/query/find.hpp>
+#include <boost/fusion/algorithm/transformation/erase.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Key>
+        struct erase_key
+          : erase<Sequence, typename find<Sequence, Key>::type>
+        {};
+    }
+
+    template <typename Key, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::erase_key<Sequence const, Key>::type
+    erase_key(Sequence const& seq)
+    {
+        return erase(seq, find<Key>(seq));
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/filter.hpp

@@ -0,0 +1,36 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2005-2006 Dan Marsden
+
+    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(FUSION_FILTER_02122005_1839)
+#define FUSION_FILTER_02122005_1839
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/filter_view/filter_view.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct filter
+        {
+            typedef filter_view<Sequence, is_same<mpl::_, T> > type;
+        };
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::filter<Sequence const, T>::type
+    filter(Sequence const& seq)
+    {
+        return filter_view<const Sequence, is_same<mpl::_, T> >(seq);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/filter_if.hpp

@@ -0,0 +1,34 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_FILTER_IF_07172005_0818)
+#define FUSION_FILTER_IF_07172005_0818
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/filter_view/filter_view.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct filter_if
+        {
+            typedef filter_view<Sequence, Pred> type;
+        };
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::filter_if<Sequence const, Pred>::type
+    filter_if(Sequence const& seq)
+    {
+        return filter_view<Sequence const, Pred>(seq);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/flatten.hpp

@@ -0,0 +1,46 @@
+/*==============================================================================
+    Copyright (c) 2013 Jamboree
+
+    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_FUSION_ALGORITHM_FLATTEN_HPP_INCLUDED
+#define BOOST_FUSION_ALGORITHM_FLATTEN_HPP_INCLUDED
+
+
+#include <boost/fusion/view/flatten_view.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+
+namespace boost { namespace fusion { namespace result_of
+{
+    template<typename Sequence>
+    struct flatten
+    {
+        typedef flatten_view<Sequence> type;
+    };
+}}}
+
+namespace boost { namespace fusion
+{
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::flatten<Sequence>::type
+    flatten(Sequence& view)
+    {
+        return flatten_view<Sequence>(view);
+    }
+
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::flatten<Sequence const>::type
+    flatten(Sequence const& view)
+    {
+        return flatten_view<Sequence const>(view);
+    }
+}}
+
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/insert.hpp

@@ -0,0 +1,69 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_INSERT_07222005_0730)
+#define FUSION_INSERT_07222005_0730
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/iterator/mpl/convert_iterator.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/view/single_view/single_view.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Position, typename T>
+        struct insert
+        {
+            typedef typename detail::as_fusion_element<T>::type element_type;
+            typedef typename convert_iterator<Position>::type pos_type;
+            typedef typename result_of::begin<Sequence>::type first_type;
+            typedef typename result_of::end<Sequence>::type last_type;
+
+            typedef iterator_range<first_type, pos_type> left_type;
+            typedef iterator_range<pos_type, last_type> right_type;
+            typedef fusion::single_view<element_type> single_view;
+            typedef joint_view<left_type, single_view const> left_insert_type;
+            typedef joint_view<left_insert_type, right_type> type;
+        };
+    }
+
+    template <typename Sequence, typename Position, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::insert<Sequence const, Position, T>
+        >::type
+    insert(Sequence const& seq, Position const& pos, T const& x)
+    {
+        typedef result_of::insert<
+            Sequence const, Position, T>
+        result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::single_view single_view;
+        typedef typename result_of::left_insert_type left_insert_type;
+        typedef typename result_of::type result;
+
+        left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos));
+        right_type right(convert_iterator<Position>::call(pos), fusion::end(seq));
+        single_view insert(x);
+        left_insert_type left_insert(left, insert);
+        return result(left_insert, right);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/insert_range.hpp

@@ -0,0 +1,56 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_INSERT_RANGE_009172005_1147)
+#define FUSION_INSERT_RANGE_009172005_1147
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/iterator/mpl/convert_iterator.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/adapted/mpl/mpl_iterator.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Position, typename Range>
+        struct insert_range
+        {
+            typedef typename convert_iterator<Position>::type pos_type;
+            typedef typename result_of::begin<Sequence>::type first_type;
+            typedef typename result_of::end<Sequence>::type last_type;
+
+            typedef iterator_range<first_type, pos_type> left_type;
+            typedef iterator_range<pos_type, last_type> right_type;
+            typedef joint_view<left_type, Range> left_insert_type;
+            typedef joint_view<left_insert_type, right_type> type;
+        };
+    }
+
+    template <typename Sequence, typename Position, typename Range>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::insert_range<Sequence const, Position, Range const>::type
+    insert_range(Sequence const& seq, Position const& pos, Range const& range)
+    {
+        typedef result_of::insert_range<Sequence const, Position, Range const> result_of;
+        typedef typename result_of::left_type left_type;
+        typedef typename result_of::right_type right_type;
+        typedef typename result_of::left_insert_type left_insert_type;
+        typedef typename result_of::type result;
+
+        left_type left(fusion::begin(seq), convert_iterator<Position>::call(pos));
+        right_type right(convert_iterator<Position>::call(pos), fusion::end(seq));
+        left_insert_type left_insert(left, range);
+        return result(left_insert, right);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/join.hpp

@@ -0,0 +1,35 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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(FUSION_JOIN_200601222109)
+#define FUSION_JOIN_200601222109
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/joint_view.hpp>
+
+namespace boost { namespace fusion {
+
+    namespace result_of
+    {
+        template<typename LhSequence, typename RhSequence>
+        struct join
+        {
+            typedef joint_view<LhSequence, RhSequence> type;
+        };
+    }
+
+    template<typename LhSequence, typename RhSequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::join<LhSequence const, RhSequence const>::type
+    join(LhSequence const& lhs, RhSequence const& rhs)
+    {
+        return typename result_of::join<LhSequence const, RhSequence const>::type(
+            lhs, rhs);
+    }
+}}
+
+#endif

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/pop_back.hpp

@@ -0,0 +1,172 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_POP_BACK_09172005_1038)
+#define FUSION_POP_BACK_09172005_1038
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/sequence/intrinsic/empty.hpp>
+#include <boost/fusion/iterator/iterator_adapter.hpp>
+#include <boost/fusion/iterator/next.hpp>
+#include <boost/mpl/minus.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace fusion
+{
+    template <typename Iterator_, bool IsLast>
+    struct pop_back_iterator
+        : iterator_adapter<
+            pop_back_iterator<Iterator_, IsLast>
+          , Iterator_>
+    {
+        typedef iterator_adapter<
+            pop_back_iterator<Iterator_, IsLast>
+          , Iterator_>
+        base_type;
+
+        static bool const is_last = IsLast;
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        pop_back_iterator(Iterator_ const& iterator_base)
+            : base_type(iterator_base) {}
+
+        template <typename BaseIterator>
+        struct make
+        {
+            typedef pop_back_iterator<BaseIterator, is_last> type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(BaseIterator const& i)
+            {
+                return type(i);
+            }
+        };
+
+        template <typename I, bool IsLast_>
+        struct equal_to_helper
+            : mpl::identity<typename I::iterator_base_type>
+        {};
+
+        template <typename I>
+        struct equal_to_helper<I, true>
+            : result_of::next<
+                typename I::iterator_base_type>
+        {};
+
+        template <typename I1, typename I2>
+        struct equal_to
+            : result_of::equal_to<
+                typename equal_to_helper<I1,
+                    (I2::is_last && !I1::is_last)>::type
+              , typename equal_to_helper<I2,
+                    (I1::is_last && !I2::is_last)>::type
+            >
+        {};
+
+        template <typename First, typename Last>
+        struct distance
+            : mpl::minus<
+                typename result_of::distance<
+                    typename First::iterator_base_type
+                  , typename Last::iterator_base_type
+                >::type
+              , mpl::int_<(Last::is_last?1:0)>
+            >::type
+        {};
+
+
+        template <typename Iterator, bool IsLast_>
+        struct prior_impl
+        {
+            typedef typename Iterator::iterator_base_type base_type;
+
+            typedef typename
+                result_of::prior<base_type>::type
+            base_prior;
+
+            typedef pop_back_iterator<base_prior, false> type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::prior(i.iterator_base));
+            }
+        };
+
+        template <typename Iterator>
+        struct prior_impl<Iterator, true>
+        {
+            // If this is the last iterator, we'll have to double back
+            typedef typename Iterator::iterator_base_type base_type;
+
+            typedef typename
+                result_of::prior<
+                  typename result_of::prior<base_type>::type
+                >::type
+            base_prior;
+
+            typedef pop_back_iterator<base_prior, false> type;
+
+            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+            static type
+            call(Iterator const& i)
+            {
+                return type(fusion::prior(
+                    fusion::prior(i.iterator_base)));
+            }
+        };
+
+        template <typename Iterator>
+        struct prior : prior_impl<Iterator, Iterator::is_last>
+        {};
+    };
+
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct pop_back
+        {
+            BOOST_MPL_ASSERT_NOT((result_of::empty<Sequence>));
+
+            typedef pop_back_iterator<
+                typename begin<Sequence>::type, false>
+            begin_type;
+
+            typedef pop_back_iterator<
+                typename end<Sequence>::type, true>
+            end_type;
+
+            typedef
+                iterator_range<begin_type, end_type>
+            type;
+        };
+    }
+
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::pop_back<Sequence const>::type
+    pop_back(Sequence const& seq)
+    {
+        typedef result_of::pop_back<Sequence const> comp;
+        typedef typename comp::begin_type begin_type;
+        typedef typename comp::end_type end_type;
+        typedef typename comp::type result;
+
+        return result(
+            begin_type(fusion::begin(seq))
+          , end_type(fusion::end(seq))
+        );
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/pop_front.hpp

@@ -0,0 +1,45 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_POP_FRONT_09172005_1115)
+#define FUSION_POP_FRONT_09172005_1115
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/iterator_range/iterator_range.hpp>
+#include <boost/fusion/sequence/intrinsic/begin.hpp>
+#include <boost/fusion/sequence/intrinsic/end.hpp>
+#include <boost/fusion/iterator/next.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct pop_front
+        {
+            typedef
+                iterator_range<
+                    typename next<
+                        typename begin<Sequence>::type
+                    >::type
+                  , typename end<Sequence>::type
+                >
+            type;
+        };
+    }
+
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::pop_front<Sequence const>::type
+    pop_front(Sequence const& seq)
+    {
+        typedef typename result_of::pop_front<Sequence const>::type result;
+        return result(fusion::next(fusion::begin(seq)), fusion::end(seq));
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/push_back.hpp

@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_PUSH_BACK_07162005_0235)
+#define FUSION_PUSH_BACK_07162005_0235
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/view/single_view/single_view.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct push_back
+        {
+            typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view;
+            typedef joint_view<Sequence, single_view const> type;
+        };
+    }
+
+    template <typename Sequence, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::push_back<Sequence const, T>
+        >::type
+    push_back(Sequence const& seq, T const& x)
+    {
+        typedef typename result_of::push_back<Sequence const, T> push_back;
+        typedef typename push_back::single_view single_view; 
+        typedef typename push_back::type result; 
+        single_view x_(x);
+        return result(seq, x_);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/push_front.hpp

@@ -0,0 +1,47 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_PUSH_FRONT_07162005_0749)
+#define FUSION_PUSH_FRONT_07162005_0749
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/as_fusion_element.hpp>
+#include <boost/fusion/view/joint_view/joint_view.hpp>
+#include <boost/fusion/view/single_view/single_view.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct push_front
+        {
+            typedef fusion::single_view<typename detail::as_fusion_element<T>::type> single_view;
+            typedef joint_view<single_view const, Sequence> type;
+        };
+    }
+
+    template <typename Sequence, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        lazy_enable_if<
+            traits::is_sequence<Sequence>
+          , result_of::push_front<Sequence const, T>
+        >::type
+    push_front(Sequence const& seq, T const& x)
+    {
+        typedef typename result_of::push_front<Sequence const, T> push_front;
+        typedef typename push_front::single_view single_view; 
+        typedef typename push_front::type result; 
+        single_view x_(x);
+        return result(x_, seq);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/remove.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REMOVE_07162005_0818)
+#define FUSION_REMOVE_07162005_0818
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/filter_view/filter_view.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct remove
+        {
+            typedef filter_view<Sequence, mpl::not_<is_same<mpl::_, T> > > type;
+        };
+    }
+
+    template <typename T, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::remove<Sequence const, T>::type
+    remove(Sequence const& seq)
+    {
+        typedef typename result_of::remove<Sequence const, T>::type result_type;
+        return result_type(seq);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/remove_if.hpp

@@ -0,0 +1,37 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REMOVE_IF_07162005_0818)
+#define FUSION_REMOVE_IF_07162005_0818
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/filter_view/filter_view.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename Pred>
+        struct remove_if
+        {
+            typedef filter_view<Sequence, mpl::not_<Pred> > type;
+        };
+    }
+
+    template <typename Pred, typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::remove_if<Sequence const, Pred>::type
+    remove_if(Sequence const& seq)
+    {
+        typedef typename result_of::remove_if<Sequence const, Pred>::type result_type;
+        return result_type(seq);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/replace.hpp

@@ -0,0 +1,43 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REPLACE_08182005_0830)
+#define FUSION_REPLACE_08182005_0830
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/transform_view/transform_view.hpp>
+#include <boost/fusion/algorithm/transformation/detail/replace.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename T>
+        struct replace
+        {
+            typedef transform_view<Sequence, detail::replacer<T> > type;
+        };
+    }
+
+    template <typename Sequence, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , typename result_of::replace<Sequence const, T>::type
+        >::type
+    replace(Sequence const& seq, T const& old_value, T const& new_value)
+    {
+        typedef typename result_of::replace<Sequence const, T>::type result;
+        detail::replacer<T> f(old_value, new_value);
+        return result(seq, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/replace_if.hpp

@@ -0,0 +1,44 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REPLACE_IF_08182005_0939)
+#define FUSION_REPLACE_IF_08182005_0939
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/transform_view/transform_view.hpp>
+#include <boost/fusion/algorithm/transformation/detail/replace_if.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence, typename F, typename T>
+        struct replace_if
+        {
+            typedef transform_view<Sequence, detail::replacer_if<F, T> > type;
+        };
+    }
+
+    template <typename Sequence, typename F, typename T>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , typename result_of::replace_if<Sequence const, F, T>::type
+        >::type
+    replace_if(Sequence const& seq, F pred, T const& new_value)
+    {
+        typedef typename result_of::replace_if<Sequence const, F, T>::type result;
+        detail::replacer_if<F, T> f(pred, new_value);
+        return result(seq, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/reverse.hpp

@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_REVERSE_07212005_1230)
+#define FUSION_REVERSE_07212005_1230
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/reverse_view/reverse_view.hpp>
+#include <boost/fusion/support/is_sequence.hpp>
+#include <boost/utility/enable_if.hpp>
+
+namespace boost { namespace fusion
+{
+    namespace result_of
+    {
+        template <typename Sequence>
+        struct reverse
+        {
+            typedef reverse_view<Sequence> type;
+        };
+    }
+
+    template <typename Sequence>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename
+        enable_if<
+            traits::is_sequence<Sequence>
+          , reverse_view<Sequence const>
+        >::type
+    reverse(Sequence const& view)
+    {
+        return reverse_view<Sequence const>(view);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/transform.hpp

@@ -0,0 +1,54 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+
+    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(FUSION_TRANSFORM_07052005_1057)
+#define FUSION_TRANSFORM_07052005_1057
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/view/transform_view/transform_view.hpp>
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template <typename Sequence1, typename Sequence2, typename F = void_>
+        struct transform
+        {
+            typedef transform_view<Sequence1, Sequence2, F> type;
+        };
+
+        template <typename Sequence, typename F>
+#if defined(BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS)
+        struct transform<Sequence, F, void_>
+#else
+        struct transform<Sequence, F>
+#endif
+        {
+            typedef transform_view<Sequence, F> type;
+        };
+    }
+
+    template <typename Sequence, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::transform<Sequence const, F>::type
+    transform(Sequence const& seq, F f)
+    {
+        return transform_view<Sequence const, F>(seq, f);
+    }
+
+    template <typename Sequence1, typename Sequence2, typename F>
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::transform<Sequence1 const, Sequence2 const, F>::type
+    transform(Sequence1 const& seq1, Sequence2 const& seq2, F f)
+    {
+        return transform_view<Sequence1 const, Sequence2 const, F>(seq1, seq2, f);
+    }
+}}
+
+#endif
+

depends/x86_64-pc-linux-gnu/include/boost/fusion/algorithm/transformation/zip.hpp

@@ -0,0 +1,118 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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_PP_IS_ITERATING
+#if !defined(FUSION_ZIP_HPP_20060125_2058)
+#define FUSION_ZIP_HPP_20060125_2058
+
+#include <boost/fusion/view/zip_view.hpp>
+#include <boost/fusion/adapted/mpl.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/vector/convert.hpp>
+#include <boost/fusion/support/detail/pp_round.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.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/preprocessor/iteration/iterate.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#if !defined(FUSION_MAX_ZIP_SEQUENCES)
+#define FUSION_MAX_ZIP_SEQUENCES 10
+#endif
+
+#define FUSION_MAX_ZIP_SEQUENCES_STR BOOST_PP_STRINGIZE(BOOST_FUSION_PP_ROUND_UP(FUSION_MAX_ZIP_SEQUENCES))
+
+#if !defined(BOOST_FUSION_DONT_USE_PREPROCESSED_FILES)
+#include <boost/fusion/algorithm/transformation/detail/preprocessed/zip.hpp>
+#else
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 2, line: 0, output: "detail/preprocessed/zip" FUSION_MAX_ZIP_SEQUENCES_STR ".hpp")
+#endif
+
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2006 Dan Marsden
+
+    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 is an auto-generated file. Do not edit!
+==============================================================================*/
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(preserve: 1)
+#endif
+
+namespace boost { namespace fusion
+{
+    struct void_;
+
+    namespace result_of
+    {
+        template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PP_INC(FUSION_MAX_ZIP_SEQUENCES), typename T, fusion::void_)>
+        struct zip;
+    }
+
+#define FUSION_TEXT(z, n, text) , text
+
+#define BOOST_PP_FILENAME_1 \
+    <boost/fusion/algorithm/transformation/zip.hpp>
+#define BOOST_PP_ITERATION_LIMITS (2, FUSION_MAX_ZIP_SEQUENCES)
+#include BOOST_PP_ITERATE()
+
+#undef FUSION_TEXT
+
+}}
+
+#if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
+#pragma wave option(output: null)
+#endif
+
+#endif // BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
+
+#endif
+
+#else
+
+#define ZIP_ITERATION BOOST_PP_ITERATION()
+
+    namespace result_of
+    {
+        template< BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, typename T) >
+        struct zip< BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, T)
+                    BOOST_PP_REPEAT_FROM_TO(BOOST_PP_DEC(ZIP_ITERATION), FUSION_MAX_ZIP_SEQUENCES, FUSION_TEXT, void_)
+        >
+        {
+            typedef mpl::vector< BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, T) > sequences;
+            typedef typename mpl::transform<sequences, add_reference<mpl::_> >::type ref_params;
+            typedef zip_view<typename result_of::as_vector<ref_params>::type> type;
+        };
+    }
+
+#define FUSION_REF_PARAM(z, n, data) const T ## n&
+
+    template<BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, typename T)>
+    BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    inline typename result_of::zip<BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, const T)>::type
+    zip(BOOST_PP_ENUM_BINARY_PARAMS(ZIP_ITERATION, T, const& t))
+    {
+        fusion::vector<BOOST_PP_ENUM(ZIP_ITERATION, FUSION_REF_PARAM, _)> seqs(
+            BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, t));
+        return typename result_of::zip<BOOST_PP_ENUM_PARAMS(ZIP_ITERATION, const T)>::type(
+            seqs);
+    }
+
+#undef FUSION_REF_PARAM
+#undef ZIP_ITERATION
+
+#endif