code:
/*=============================================================================
    Copyright (c) 2011 Thomas Heller

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/

        template <typename F, typename A0>
        struct has_phx2_result<F, A0>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0)> >
            >::type
        {};
        template <typename F, typename A0>
        struct phx2_result<F, A0>
        {
            typedef typename F::template result<A0>::type type;
        };
        template <typename F, typename A0>
        struct phx2_result<F, A0 &>
        {
            typedef typename F::template result<A0>::type type;
        };
        template <typename F, typename A0>
        struct phx2_result<F, A0 const&>
        {
            typedef typename F::template result<A0>::type type;
        };

        template <typename F, typename A0 , typename A1>
        struct has_phx2_result<F, A0 , A1>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 , A1>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 & , A1 &>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };
        template <typename F, typename A0 , typename A1>
        struct phx2_result<F, A0 const& , A1 const&>
        {
            typedef typename F::template result<A0 , A1>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2>
        struct has_phx2_result<F, A0 , A1 , A2>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 , A1 , A2>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 & , A1 & , A2 &>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2>
        struct phx2_result<F, A0 const& , A1 const& , A2 const&>
        {
            typedef typename F::template result<A0 , A1 , A2>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct has_phx2_result<F, A0 , A1 , A2 , A3>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 , A1 , A2 , A3>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type type;
        };

        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct has_phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
            : mpl::eval_if<
                has_result_type<F>
              , mpl::false_
              , has_phx2_result_impl<typename F::template result<F(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
            >::type
        {};
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 & , A1 & , A2 & , A3 & , A4 & , A5 & , A6 & , A7 & , A8 &>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };
        template <typename F, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
        struct phx2_result<F, A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const&>
        {
            typedef typename F::template result<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type type;
        };


code:
/*
 [auto_generated]
 boost/numeric/odeint/stepper/symplectic_euler.hpp

 [begin_description]
 Implementation of the symplectic Euler for separable Hamiltonian systems.
 [end_description]

 Copyright 2011-2013 Karsten Ahnert
 Copyright 2011-2013 Mario Mulansky

 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_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED
#define BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED

#include <boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp>

#include <boost/numeric/odeint/algebra/range_algebra.hpp>
#include <boost/numeric/odeint/algebra/default_operations.hpp>
#include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
#include <boost/numeric/odeint/algebra/operations_dispatcher.hpp>

#include <boost/array.hpp>

namespace boost {
namespace numeric {
namespace odeint {

#ifndef DOXYGEN_SKIP
namespace detail {
namespace symplectic_euler_coef {

template< class Value >
struct coef_a_type : public boost::array< Value , 1 >
{
    coef_a_type( void )
    {
        (*this)[0] = static_cast< Value >( 1 );
    }
};

template< class Value >
struct coef_b_type : public boost::array< Value , 1 >
{
    coef_b_type( void )
    {
        (*this)[0] = static_cast< Value >( 1 );
    }
};

} // namespace symplectic_euler_coef
} // namespace detail
#endif

template<
class Coor ,
class Momentum = Coor ,
class Value = double ,
class CoorDeriv = Coor ,
class MomentumDeriv = Coor ,
class Time = Value ,
class Algebra = typename algebra_dispatcher< Coor >::algebra_type ,
class Operations = typename operations_dispatcher< Coor >::operations_type ,
class Resizer = initially_resizer
>
#ifndef DOXYGEN_SKIP
class symplectic_euler :
public symplectic_nystroem_stepper_base
<
1 , 1 ,
Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer
>
#else
class symplectic_euler : public symplectic_nystroem_stepper_base
#endif
{
public:

#ifndef DOXYGEN_SKIP
    typedef symplectic_nystroem_stepper_base<
    1 , 1 , Coor , Momentum , Value , CoorDeriv , MomentumDeriv , Time , Algebra , Operations , Resizer > stepper_base_type;
#endif
    typedef typename stepper_base_type::algebra_type algebra_type;
    typedef typename stepper_base_type::value_type value_type;

    symplectic_euler( const algebra_type &algebra = algebra_type() )
    : stepper_base_type( detail::symplectic_euler_coef::coef_a_type< value_type >() ,
            detail::symplectic_euler_coef::coef_b_type< value_type >() ,
            algebra )
    { }
};

/*************** DOXYGEN ***************/

/**
 * \class symplectic_euler
 * \brief Implementation of the symplectic Euler method.
 *
 * The method is of first order and has one stage. It is described HERE.
 *
 * \tparam Order The order of the stepper.
 * \tparam Coor The type representing the coordinates q.
 * \tparam Momentum The type representing the coordinates p.
 * \tparam Value The basic value type. Should be something like float, double or a high-precision type.
 * \tparam CoorDeriv The type representing the time derivative of the coordinate dq/dt.
 * \tparam MomemtnumDeriv The type representing the time derivative of the momentum dp/dt.
 * \tparam Time The type representing the time t.
 * \tparam Algebra The algebra.
 * \tparam Operations The operations.
 * \tparam Resizer The resizer policy.
 */

    /**
     * \fn symplectic_euler::symplectic_euler( const algebra_type &algebra )
     * \brief Constructs the symplectic_euler. This constructor can be used as a default
     * constructor if the algebra has a default constructor.
     * \param algebra A copy of algebra is made and stored inside explicit_stepper_base.
     */

} // namespace odeint
} // namespace numeric
} // namespace boost

#endif // BOOST_NUMERIC_ODEINT_STEPPER_SYMPLECTIC_EULER_HPP_INCLUDED

license: mit


code:
/*=============================================================================
    Copyright (c) 2005-2012 Joel de Guzman
    Copyright (c) 2005-2006 Dan Marsden
    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_CONVERT_IMPL_20061213_2207)
#define FUSION_CONVERT_IMPL_20061213_2207

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/container/deque/convert.hpp>
#include <boost/fusion/container/deque/deque.hpp>
#include <boost/fusion/sequence/intrinsic/begin.hpp>
#include <boost/fusion/sequence/intrinsic/end.hpp>

namespace boost { namespace fusion
{
    struct deque_tag;

    namespace result_of
    {
        template <typename Sequence>
        struct as_deque;
    }

    namespace extension
    {
        template <typename T>
        struct convert_impl;

        template <>
        struct convert_impl<deque_tag>
        {
            template <typename Sequence>
            struct apply
            {
                typedef result_of::as_deque<Sequence> gen;
                typedef typename gen::type type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type call(Sequence& seq)
                {
                    return gen::call(fusion::begin(seq)
#if defined(BOOST_FUSION_HAS_VARIADIC_DEQUE)
                        , fusion::end(seq)
#endif
                    );
                }
            };
        };
    }
}}

#endif


code:
# /* **************************************************************************
#  *                                                                          *
#  *     (C) Copyright Paul Mensonides 2002.
#  *     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)
#  *                                                                          *
#  ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# if BOOST_PP_ITERATION_FINISH_2 <= 256 && BOOST_PP_ITERATION_START_2 >= 256
#    define BOOST_PP_ITERATION_2 256
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 255 && BOOST_PP_ITERATION_START_2 >= 255
#    define BOOST_PP_ITERATION_2 255
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 254 && BOOST_PP_ITERATION_START_2 >= 254
#    define BOOST_PP_ITERATION_2 254
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 253 && BOOST_PP_ITERATION_START_2 >= 253
#    define BOOST_PP_ITERATION_2 253
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 252 && BOOST_PP_ITERATION_START_2 >= 252
#    define BOOST_PP_ITERATION_2 252
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 251 && BOOST_PP_ITERATION_START_2 >= 251
#    define BOOST_PP_ITERATION_2 251
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 250 && BOOST_PP_ITERATION_START_2 >= 250
#    define BOOST_PP_ITERATION_2 250
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 249 && BOOST_PP_ITERATION_START_2 >= 249
#    define BOOST_PP_ITERATION_2 249
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 248 && BOOST_PP_ITERATION_START_2 >= 248
#    define BOOST_PP_ITERATION_2 248
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 247 && BOOST_PP_ITERATION_START_2 >= 247
#    define BOOST_PP_ITERATION_2 247
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 246 && BOOST_PP_ITERATION_START_2 >= 246
#    define BOOST_PP_ITERATION_2 246
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 245 && BOOST_PP_ITERATION_START_2 >= 245
#    define BOOST_PP_ITERATION_2 245
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 244 && BOOST_PP_ITERATION_START_2 >= 244
#    define BOOST_PP_ITERATION_2 244
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 243 && BOOST_PP_ITERATION_START_2 >= 243
#    define BOOST_PP_ITERATION_2 243
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 242 && BOOST_PP_ITERATION_START_2 >= 242
#    define BOOST_PP_ITERATION_2 242
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 241 && BOOST_PP_ITERATION_START_2 >= 241
#    define BOOST_PP_ITERATION_2 241
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 240 && BOOST_PP_ITERATION_START_2 >= 240
#    define BOOST_PP_ITERATION_2 240
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 239 && BOOST_PP_ITERATION_START_2 >= 239
#    define BOOST_PP_ITERATION_2 239
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 238 && BOOST_PP_ITERATION_START_2 >= 238
#    define BOOST_PP_ITERATION_2 238
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 237 && BOOST_PP_ITERATION_START_2 >= 237
#    define BOOST_PP_ITERATION_2 237
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 236 && BOOST_PP_ITERATION_START_2 >= 236
#    define BOOST_PP_ITERATION_2 236
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 235 && BOOST_PP_ITERATION_START_2 >= 235
#    define BOOST_PP_ITERATION_2 235
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 234 && BOOST_PP_ITERATION_START_2 >= 234
#    define BOOST_PP_ITERATION_2 234
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 233 && BOOST_PP_ITERATION_START_2 >= 233
#    define BOOST_PP_ITERATION_2 233
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 232 && BOOST_PP_ITERATION_START_2 >= 232
#    define BOOST_PP_ITERATION_2 232
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 231 && BOOST_PP_ITERATION_START_2 >= 231
#    define BOOST_PP_ITERATION_2 231
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 230 && BOOST_PP_ITERATION_START_2 >= 230
#    define BOOST_PP_ITERATION_2 230
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 229 && BOOST_PP_ITERATION_START_2 >= 229
#    define BOOST_PP_ITERATION_2 229
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 228 && BOOST_PP_ITERATION_START_2 >= 228
#    define BOOST_PP_ITERATION_2 228
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 227 && BOOST_PP_ITERATION_START_2 >= 227
#    define BOOST_PP_ITERATION_2 227
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 226 && BOOST_PP_ITERATION_START_2 >= 226
#    define BOOST_PP_ITERATION_2 226
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 225 && BOOST_PP_ITERATION_START_2 >= 225
#    define BOOST_PP_ITERATION_2 225
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 224 && BOOST_PP_ITERATION_START_2 >= 224
#    define BOOST_PP_ITERATION_2 224
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 223 && BOOST_PP_ITERATION_START_2 >= 223
#    define BOOST_PP_ITERATION_2 223
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 222 && BOOST_PP_ITERATION_START_2 >= 222
#    define BOOST_PP_ITERATION_2 222
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 221 && BOOST_PP_ITERATION_START_2 >= 221
#    define BOOST_PP_ITERATION_2 221
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 220 && BOOST_PP_ITERATION_START_2 >= 220
#    define BOOST_PP_ITERATION_2 220
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 219 && BOOST_PP_ITERATION_START_2 >= 219
#    define BOOST_PP_ITERATION_2 219
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 218 && BOOST_PP_ITERATION_START_2 >= 218
#    define BOOST_PP_ITERATION_2 218
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 217 && BOOST_PP_ITERATION_START_2 >= 217
#    define BOOST_PP_ITERATION_2 217
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 216 && BOOST_PP_ITERATION_START_2 >= 216
#    define BOOST_PP_ITERATION_2 216
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 215 && BOOST_PP_ITERATION_START_2 >= 215
#    define BOOST_PP_ITERATION_2 215
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 214 && BOOST_PP_ITERATION_START_2 >= 214
#    define BOOST_PP_ITERATION_2 214
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 213 && BOOST_PP_ITERATION_START_2 >= 213
#    define BOOST_PP_ITERATION_2 213
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 212 && BOOST_PP_ITERATION_START_2 >= 212
#    define BOOST_PP_ITERATION_2 212
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 211 && BOOST_PP_ITERATION_START_2 >= 211
#    define BOOST_PP_ITERATION_2 211
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 210 && BOOST_PP_ITERATION_START_2 >= 210
#    define BOOST_PP_ITERATION_2 210
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 209 && BOOST_PP_ITERATION_START_2 >= 209
#    define BOOST_PP_ITERATION_2 209
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 208 && BOOST_PP_ITERATION_START_2 >= 208
#    define BOOST_PP_ITERATION_2 208
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 207 && BOOST_PP_ITERATION_START_2 >= 207
#    define BOOST_PP_ITERATION_2 207
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 206 && BOOST_PP_ITERATION_START_2 >= 206
#    define BOOST_PP_ITERATION_2 206
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 205 && BOOST_PP_ITERATION_START_2 >= 205
#    define BOOST_PP_ITERATION_2 205
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 204 && BOOST_PP_ITERATION_START_2 >= 204
#    define BOOST_PP_ITERATION_2 204
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 203 && BOOST_PP_ITERATION_START_2 >= 203
#    define BOOST_PP_ITERATION_2 203
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 202 && BOOST_PP_ITERATION_START_2 >= 202
#    define BOOST_PP_ITERATION_2 202
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 201 && BOOST_PP_ITERATION_START_2 >= 201
#    define BOOST_PP_ITERATION_2 201
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 200 && BOOST_PP_ITERATION_START_2 >= 200
#    define BOOST_PP_ITERATION_2 200
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 199 && BOOST_PP_ITERATION_START_2 >= 199
#    define BOOST_PP_ITERATION_2 199
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 198 && BOOST_PP_ITERATION_START_2 >= 198
#    define BOOST_PP_ITERATION_2 198
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 197 && BOOST_PP_ITERATION_START_2 >= 197
#    define BOOST_PP_ITERATION_2 197
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 196 && BOOST_PP_ITERATION_START_2 >= 196
#    define BOOST_PP_ITERATION_2 196
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 195 && BOOST_PP_ITERATION_START_2 >= 195
#    define BOOST_PP_ITERATION_2 195
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 194 && BOOST_PP_ITERATION_START_2 >= 194
#    define BOOST_PP_ITERATION_2 194
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 193 && BOOST_PP_ITERATION_START_2 >= 193
#    define BOOST_PP_ITERATION_2 193
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 192 && BOOST_PP_ITERATION_START_2 >= 192
#    define BOOST_PP_ITERATION_2 192
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 191 && BOOST_PP_ITERATION_START_2 >= 191
#    define BOOST_PP_ITERATION_2 191
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 190 && BOOST_PP_ITERATION_START_2 >= 190
#    define BOOST_PP_ITERATION_2 190
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 189 && BOOST_PP_ITERATION_START_2 >= 189
#    define BOOST_PP_ITERATION_2 189
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 188 && BOOST_PP_ITERATION_START_2 >= 188
#    define BOOST_PP_ITERATION_2 188
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 187 && BOOST_PP_ITERATION_START_2 >= 187
#    define BOOST_PP_ITERATION_2 187
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 186 && BOOST_PP_ITERATION_START_2 >= 186
#    define BOOST_PP_ITERATION_2 186
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 185 && BOOST_PP_ITERATION_START_2 >= 185
#    define BOOST_PP_ITERATION_2 185
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 184 && BOOST_PP_ITERATION_START_2 >= 184
#    define BOOST_PP_ITERATION_2 184
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 183 && BOOST_PP_ITERATION_START_2 >= 183
#    define BOOST_PP_ITERATION_2 183
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 182 && BOOST_PP_ITERATION_START_2 >= 182
#    define BOOST_PP_ITERATION_2 182
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 181 && BOOST_PP_ITERATION_START_2 >= 181
#    define BOOST_PP_ITERATION_2 181
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 180 && BOOST_PP_ITERATION_START_2 >= 180
#    define BOOST_PP_ITERATION_2 180
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 179 && BOOST_PP_ITERATION_START_2 >= 179
#    define BOOST_PP_ITERATION_2 179
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 178 && BOOST_PP_ITERATION_START_2 >= 178
#    define BOOST_PP_ITERATION_2 178
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 177 && BOOST_PP_ITERATION_START_2 >= 177
#    define BOOST_PP_ITERATION_2 177
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 176 && BOOST_PP_ITERATION_START_2 >= 176
#    define BOOST_PP_ITERATION_2 176
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 175 && BOOST_PP_ITERATION_START_2 >= 175
#    define BOOST_PP_ITERATION_2 175
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 174 && BOOST_PP_ITERATION_START_2 >= 174
#    define BOOST_PP_ITERATION_2 174
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 173 && BOOST_PP_ITERATION_START_2 >= 173
#    define BOOST_PP_ITERATION_2 173
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 172 && BOOST_PP_ITERATION_START_2 >= 172
#    define BOOST_PP_ITERATION_2 172
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 171 && BOOST_PP_ITERATION_START_2 >= 171
#    define BOOST_PP_ITERATION_2 171
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 170 && BOOST_PP_ITERATION_START_2 >= 170
#    define BOOST_PP_ITERATION_2 170
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 169 && BOOST_PP_ITERATION_START_2 >= 169
#    define BOOST_PP_ITERATION_2 169
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 168 && BOOST_PP_ITERATION_START_2 >= 168
#    define BOOST_PP_ITERATION_2 168
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 167 && BOOST_PP_ITERATION_START_2 >= 167
#    define BOOST_PP_ITERATION_2 167
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 166 && BOOST_PP_ITERATION_START_2 >= 166
#    define BOOST_PP_ITERATION_2 166
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 165 && BOOST_PP_ITERATION_START_2 >= 165
#    define BOOST_PP_ITERATION_2 165
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 164 && BOOST_PP_ITERATION_START_2 >= 164
#    define BOOST_PP_ITERATION_2 164
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 163 && BOOST_PP_ITERATION_START_2 >= 163
#    define BOOST_PP_ITERATION_2 163
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 162 && BOOST_PP_ITERATION_START_2 >= 162
#    define BOOST_PP_ITERATION_2 162
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 161 && BOOST_PP_ITERATION_START_2 >= 161
#    define BOOST_PP_ITERATION_2 161
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 160 && BOOST_PP_ITERATION_START_2 >= 160
#    define BOOST_PP_ITERATION_2 160
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 159 && BOOST_PP_ITERATION_START_2 >= 159
#    define BOOST_PP_ITERATION_2 159
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 158 && BOOST_PP_ITERATION_START_2 >= 158
#    define BOOST_PP_ITERATION_2 158
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 157 && BOOST_PP_ITERATION_START_2 >= 157
#    define BOOST_PP_ITERATION_2 157
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 156 && BOOST_PP_ITERATION_START_2 >= 156
#    define BOOST_PP_ITERATION_2 156
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 155 && BOOST_PP_ITERATION_START_2 >= 155
#    define BOOST_PP_ITERATION_2 155
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 154 && BOOST_PP_ITERATION_START_2 >= 154
#    define BOOST_PP_ITERATION_2 154
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 153 && BOOST_PP_ITERATION_START_2 >= 153
#    define BOOST_PP_ITERATION_2 153
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 152 && BOOST_PP_ITERATION_START_2 >= 152
#    define BOOST_PP_ITERATION_2 152
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 151 && BOOST_PP_ITERATION_START_2 >= 151
#    define BOOST_PP_ITERATION_2 151
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 150 && BOOST_PP_ITERATION_START_2 >= 150
#    define BOOST_PP_ITERATION_2 150
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 149 && BOOST_PP_ITERATION_START_2 >= 149
#    define BOOST_PP_ITERATION_2 149
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 148 && BOOST_PP_ITERATION_START_2 >= 148
#    define BOOST_PP_ITERATION_2 148
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 147 && BOOST_PP_ITERATION_START_2 >= 147
#    define BOOST_PP_ITERATION_2 147
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 146 && BOOST_PP_ITERATION_START_2 >= 146
#    define BOOST_PP_ITERATION_2 146
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 145 && BOOST_PP_ITERATION_START_2 >= 145
#    define BOOST_PP_ITERATION_2 145
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 144 && BOOST_PP_ITERATION_START_2 >= 144
#    define BOOST_PP_ITERATION_2 144
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 143 && BOOST_PP_ITERATION_START_2 >= 143
#    define BOOST_PP_ITERATION_2 143
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 142 && BOOST_PP_ITERATION_START_2 >= 142
#    define BOOST_PP_ITERATION_2 142
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 141 && BOOST_PP_ITERATION_START_2 >= 141
#    define BOOST_PP_ITERATION_2 141
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 140 && BOOST_PP_ITERATION_START_2 >= 140
#    define BOOST_PP_ITERATION_2 140
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 139 && BOOST_PP_ITERATION_START_2 >= 139
#    define BOOST_PP_ITERATION_2 139
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 138 && BOOST_PP_ITERATION_START_2 >= 138
#    define BOOST_PP_ITERATION_2 138
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 137 && BOOST_PP_ITERATION_START_2 >= 137
#    define BOOST_PP_ITERATION_2 137
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 136 && BOOST_PP_ITERATION_START_2 >= 136
#    define BOOST_PP_ITERATION_2 136
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 135 && BOOST_PP_ITERATION_START_2 >= 135
#    define BOOST_PP_ITERATION_2 135
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 134 && BOOST_PP_ITERATION_START_2 >= 134
#    define BOOST_PP_ITERATION_2 134
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 133 && BOOST_PP_ITERATION_START_2 >= 133
#    define BOOST_PP_ITERATION_2 133
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 132 && BOOST_PP_ITERATION_START_2 >= 132
#    define BOOST_PP_ITERATION_2 132
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 131 && BOOST_PP_ITERATION_START_2 >= 131
#    define BOOST_PP_ITERATION_2 131
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 130 && BOOST_PP_ITERATION_START_2 >= 130
#    define BOOST_PP_ITERATION_2 130
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 129 && BOOST_PP_ITERATION_START_2 >= 129
#    define BOOST_PP_ITERATION_2 129
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 128 && BOOST_PP_ITERATION_START_2 >= 128
#    define BOOST_PP_ITERATION_2 128
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 127 && BOOST_PP_ITERATION_START_2 >= 127
#    define BOOST_PP_ITERATION_2 127
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 126 && BOOST_PP_ITERATION_START_2 >= 126
#    define BOOST_PP_ITERATION_2 126
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 125 && BOOST_PP_ITERATION_START_2 >= 125
#    define BOOST_PP_ITERATION_2 125
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 124 && BOOST_PP_ITERATION_START_2 >= 124
#    define BOOST_PP_ITERATION_2 124
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 123 && BOOST_PP_ITERATION_START_2 >= 123
#    define BOOST_PP_ITERATION_2 123
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 122 && BOOST_PP_ITERATION_START_2 >= 122
#    define BOOST_PP_ITERATION_2 122
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 121 && BOOST_PP_ITERATION_START_2 >= 121
#    define BOOST_PP_ITERATION_2 121
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 120 && BOOST_PP_ITERATION_START_2 >= 120
#    define BOOST_PP_ITERATION_2 120
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 119 && BOOST_PP_ITERATION_START_2 >= 119
#    define BOOST_PP_ITERATION_2 119
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 118 && BOOST_PP_ITERATION_START_2 >= 118
#    define BOOST_PP_ITERATION_2 118
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 117 && BOOST_PP_ITERATION_START_2 >= 117
#    define BOOST_PP_ITERATION_2 117
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 116 && BOOST_PP_ITERATION_START_2 >= 116
#    define BOOST_PP_ITERATION_2 116
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 115 && BOOST_PP_ITERATION_START_2 >= 115
#    define BOOST_PP_ITERATION_2 115
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 114 && BOOST_PP_ITERATION_START_2 >= 114
#    define BOOST_PP_ITERATION_2 114
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 113 && BOOST_PP_ITERATION_START_2 >= 113
#    define BOOST_PP_ITERATION_2 113
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 112 && BOOST_PP_ITERATION_START_2 >= 112
#    define BOOST_PP_ITERATION_2 112
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 111 && BOOST_PP_ITERATION_START_2 >= 111
#    define BOOST_PP_ITERATION_2 111
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 110 && BOOST_PP_ITERATION_START_2 >= 110
#    define BOOST_PP_ITERATION_2 110
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 109 && BOOST_PP_ITERATION_START_2 >= 109
#    define BOOST_PP_ITERATION_2 109
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 108 && BOOST_PP_ITERATION_START_2 >= 108
#    define BOOST_PP_ITERATION_2 108
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 107 && BOOST_PP_ITERATION_START_2 >= 107
#    define BOOST_PP_ITERATION_2 107
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 106 && BOOST_PP_ITERATION_START_2 >= 106
#    define BOOST_PP_ITERATION_2 106
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 105 && BOOST_PP_ITERATION_START_2 >= 105
#    define BOOST_PP_ITERATION_2 105
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 104 && BOOST_PP_ITERATION_START_2 >= 104
#    define BOOST_PP_ITERATION_2 104
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 103 && BOOST_PP_ITERATION_START_2 >= 103
#    define BOOST_PP_ITERATION_2 103
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 102 && BOOST_PP_ITERATION_START_2 >= 102
#    define BOOST_PP_ITERATION_2 102
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 101 && BOOST_PP_ITERATION_START_2 >= 101
#    define BOOST_PP_ITERATION_2 101
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 100 && BOOST_PP_ITERATION_START_2 >= 100
#    define BOOST_PP_ITERATION_2 100
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 99 && BOOST_PP_ITERATION_START_2 >= 99
#    define BOOST_PP_ITERATION_2 99
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 98 && BOOST_PP_ITERATION_START_2 >= 98
#    define BOOST_PP_ITERATION_2 98
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 97 && BOOST_PP_ITERATION_START_2 >= 97
#    define BOOST_PP_ITERATION_2 97
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 96 && BOOST_PP_ITERATION_START_2 >= 96
#    define BOOST_PP_ITERATION_2 96
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 95 && BOOST_PP_ITERATION_START_2 >= 95
#    define BOOST_PP_ITERATION_2 95
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 94 && BOOST_PP_ITERATION_START_2 >= 94
#    define BOOST_PP_ITERATION_2 94
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 93 && BOOST_PP_ITERATION_START_2 >= 93
#    define BOOST_PP_ITERATION_2 93
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 92 && BOOST_PP_ITERATION_START_2 >= 92
#    define BOOST_PP_ITERATION_2 92
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 91 && BOOST_PP_ITERATION_START_2 >= 91
#    define BOOST_PP_ITERATION_2 91
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 90 && BOOST_PP_ITERATION_START_2 >= 90
#    define BOOST_PP_ITERATION_2 90
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 89 && BOOST_PP_ITERATION_START_2 >= 89
#    define BOOST_PP_ITERATION_2 89
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 88 && BOOST_PP_ITERATION_START_2 >= 88
#    define BOOST_PP_ITERATION_2 88
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 87 && BOOST_PP_ITERATION_START_2 >= 87
#    define BOOST_PP_ITERATION_2 87
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 86 && BOOST_PP_ITERATION_START_2 >= 86
#    define BOOST_PP_ITERATION_2 86
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 85 && BOOST_PP_ITERATION_START_2 >= 85
#    define BOOST_PP_ITERATION_2 85
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 84 && BOOST_PP_ITERATION_START_2 >= 84
#    define BOOST_PP_ITERATION_2 84
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 83 && BOOST_PP_ITERATION_START_2 >= 83
#    define BOOST_PP_ITERATION_2 83
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 82 && BOOST_PP_ITERATION_START_2 >= 82
#    define BOOST_PP_ITERATION_2 82
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 81 && BOOST_PP_ITERATION_START_2 >= 81
#    define BOOST_PP_ITERATION_2 81
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 80 && BOOST_PP_ITERATION_START_2 >= 80
#    define BOOST_PP_ITERATION_2 80
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 79 && BOOST_PP_ITERATION_START_2 >= 79
#    define BOOST_PP_ITERATION_2 79
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 78 && BOOST_PP_ITERATION_START_2 >= 78
#    define BOOST_PP_ITERATION_2 78
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 77 && BOOST_PP_ITERATION_START_2 >= 77
#    define BOOST_PP_ITERATION_2 77
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 76 && BOOST_PP_ITERATION_START_2 >= 76
#    define BOOST_PP_ITERATION_2 76
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 75 && BOOST_PP_ITERATION_START_2 >= 75
#    define BOOST_PP_ITERATION_2 75
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 74 && BOOST_PP_ITERATION_START_2 >= 74
#    define BOOST_PP_ITERATION_2 74
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 73 && BOOST_PP_ITERATION_START_2 >= 73
#    define BOOST_PP_ITERATION_2 73
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 72 && BOOST_PP_ITERATION_START_2 >= 72
#    define BOOST_PP_ITERATION_2 72
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 71 && BOOST_PP_ITERATION_START_2 >= 71
#    define BOOST_PP_ITERATION_2 71
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 70 && BOOST_PP_ITERATION_START_2 >= 70
#    define BOOST_PP_ITERATION_2 70
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 69 && BOOST_PP_ITERATION_START_2 >= 69
#    define BOOST_PP_ITERATION_2 69
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 68 && BOOST_PP_ITERATION_START_2 >= 68
#    define BOOST_PP_ITERATION_2 68
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 67 && BOOST_PP_ITERATION_START_2 >= 67
#    define BOOST_PP_ITERATION_2 67
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 66 && BOOST_PP_ITERATION_START_2 >= 66
#    define BOOST_PP_ITERATION_2 66
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 65 && BOOST_PP_ITERATION_START_2 >= 65
#    define BOOST_PP_ITERATION_2 65
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 64 && BOOST_PP_ITERATION_START_2 >= 64
#    define BOOST_PP_ITERATION_2 64
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 63 && BOOST_PP_ITERATION_START_2 >= 63
#    define BOOST_PP_ITERATION_2 63
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 62 && BOOST_PP_ITERATION_START_2 >= 62
#    define BOOST_PP_ITERATION_2 62
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 61 && BOOST_PP_ITERATION_START_2 >= 61
#    define BOOST_PP_ITERATION_2 61
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 60 && BOOST_PP_ITERATION_START_2 >= 60
#    define BOOST_PP_ITERATION_2 60
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 59 && BOOST_PP_ITERATION_START_2 >= 59
#    define BOOST_PP_ITERATION_2 59
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 58 && BOOST_PP_ITERATION_START_2 >= 58
#    define BOOST_PP_ITERATION_2 58
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 57 && BOOST_PP_ITERATION_START_2 >= 57
#    define BOOST_PP_ITERATION_2 57
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 56 && BOOST_PP_ITERATION_START_2 >= 56
#    define BOOST_PP_ITERATION_2 56
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 55 && BOOST_PP_ITERATION_START_2 >= 55
#    define BOOST_PP_ITERATION_2 55
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 54 && BOOST_PP_ITERATION_START_2 >= 54
#    define BOOST_PP_ITERATION_2 54
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 53 && BOOST_PP_ITERATION_START_2 >= 53
#    define BOOST_PP_ITERATION_2 53
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 52 && BOOST_PP_ITERATION_START_2 >= 52
#    define BOOST_PP_ITERATION_2 52
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 51 && BOOST_PP_ITERATION_START_2 >= 51
#    define BOOST_PP_ITERATION_2 51
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 50 && BOOST_PP_ITERATION_START_2 >= 50
#    define BOOST_PP_ITERATION_2 50
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 49 && BOOST_PP_ITERATION_START_2 >= 49
#    define BOOST_PP_ITERATION_2 49
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 48 && BOOST_PP_ITERATION_START_2 >= 48
#    define BOOST_PP_ITERATION_2 48
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 47 && BOOST_PP_ITERATION_START_2 >= 47
#    define BOOST_PP_ITERATION_2 47
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 46 && BOOST_PP_ITERATION_START_2 >= 46
#    define BOOST_PP_ITERATION_2 46
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 45 && BOOST_PP_ITERATION_START_2 >= 45
#    define BOOST_PP_ITERATION_2 45
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 44 && BOOST_PP_ITERATION_START_2 >= 44
#    define BOOST_PP_ITERATION_2 44
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 43 && BOOST_PP_ITERATION_START_2 >= 43
#    define BOOST_PP_ITERATION_2 43
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 42 && BOOST_PP_ITERATION_START_2 >= 42
#    define BOOST_PP_ITERATION_2 42
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 41 && BOOST_PP_ITERATION_START_2 >= 41
#    define BOOST_PP_ITERATION_2 41
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 40 && BOOST_PP_ITERATION_START_2 >= 40
#    define BOOST_PP_ITERATION_2 40
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 39 && BOOST_PP_ITERATION_START_2 >= 39
#    define BOOST_PP_ITERATION_2 39
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 38 && BOOST_PP_ITERATION_START_2 >= 38
#    define BOOST_PP_ITERATION_2 38
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 37 && BOOST_PP_ITERATION_START_2 >= 37
#    define BOOST_PP_ITERATION_2 37
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 36 && BOOST_PP_ITERATION_START_2 >= 36
#    define BOOST_PP_ITERATION_2 36
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 35 && BOOST_PP_ITERATION_START_2 >= 35
#    define BOOST_PP_ITERATION_2 35
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 34 && BOOST_PP_ITERATION_START_2 >= 34
#    define BOOST_PP_ITERATION_2 34
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 33 && BOOST_PP_ITERATION_START_2 >= 33
#    define BOOST_PP_ITERATION_2 33
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 32 && BOOST_PP_ITERATION_START_2 >= 32
#    define BOOST_PP_ITERATION_2 32
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 31 && BOOST_PP_ITERATION_START_2 >= 31
#    define BOOST_PP_ITERATION_2 31
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 30 && BOOST_PP_ITERATION_START_2 >= 30
#    define BOOST_PP_ITERATION_2 30
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 29 && BOOST_PP_ITERATION_START_2 >= 29
#    define BOOST_PP_ITERATION_2 29
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 28 && BOOST_PP_ITERATION_START_2 >= 28
#    define BOOST_PP_ITERATION_2 28
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 27 && BOOST_PP_ITERATION_START_2 >= 27
#    define BOOST_PP_ITERATION_2 27
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 26 && BOOST_PP_ITERATION_START_2 >= 26
#    define BOOST_PP_ITERATION_2 26
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 25 && BOOST_PP_ITERATION_START_2 >= 25
#    define BOOST_PP_ITERATION_2 25
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 24 && BOOST_PP_ITERATION_START_2 >= 24
#    define BOOST_PP_ITERATION_2 24
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 23 && BOOST_PP_ITERATION_START_2 >= 23
#    define BOOST_PP_ITERATION_2 23
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 22 && BOOST_PP_ITERATION_START_2 >= 22
#    define BOOST_PP_ITERATION_2 22
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 21 && BOOST_PP_ITERATION_START_2 >= 21
#    define BOOST_PP_ITERATION_2 21
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 20 && BOOST_PP_ITERATION_START_2 >= 20
#    define BOOST_PP_ITERATION_2 20
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 19 && BOOST_PP_ITERATION_START_2 >= 19
#    define BOOST_PP_ITERATION_2 19
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 18 && BOOST_PP_ITERATION_START_2 >= 18
#    define BOOST_PP_ITERATION_2 18
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 17 && BOOST_PP_ITERATION_START_2 >= 17
#    define BOOST_PP_ITERATION_2 17
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 16 && BOOST_PP_ITERATION_START_2 >= 16
#    define BOOST_PP_ITERATION_2 16
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 15 && BOOST_PP_ITERATION_START_2 >= 15
#    define BOOST_PP_ITERATION_2 15
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 14 && BOOST_PP_ITERATION_START_2 >= 14
#    define BOOST_PP_ITERATION_2 14
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 13 && BOOST_PP_ITERATION_START_2 >= 13
#    define BOOST_PP_ITERATION_2 13
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 12 && BOOST_PP_ITERATION_START_2 >= 12
#    define BOOST_PP_ITERATION_2 12
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 11 && BOOST_PP_ITERATION_START_2 >= 11
#    define BOOST_PP_ITERATION_2 11
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 10 && BOOST_PP_ITERATION_START_2 >= 10
#    define BOOST_PP_ITERATION_2 10
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 9 && BOOST_PP_ITERATION_START_2 >= 9
#    define BOOST_PP_ITERATION_2 9
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 8 && BOOST_PP_ITERATION_START_2 >= 8
#    define BOOST_PP_ITERATION_2 8
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 7 && BOOST_PP_ITERATION_START_2 >= 7
#    define BOOST_PP_ITERATION_2 7
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 6 && BOOST_PP_ITERATION_START_2 >= 6
#    define BOOST_PP_ITERATION_2 6
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 5 && BOOST_PP_ITERATION_START_2 >= 5
#    define BOOST_PP_ITERATION_2 5
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 4 && BOOST_PP_ITERATION_START_2 >= 4
#    define BOOST_PP_ITERATION_2 4
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 3 && BOOST_PP_ITERATION_START_2 >= 3
#    define BOOST_PP_ITERATION_2 3
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 2 && BOOST_PP_ITERATION_START_2 >= 2
#    define BOOST_PP_ITERATION_2 2
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 1 && BOOST_PP_ITERATION_START_2 >= 1
#    define BOOST_PP_ITERATION_2 1
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 0 && BOOST_PP_ITERATION_START_2 >= 0
#    define BOOST_PP_ITERATION_2 0
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif


code:
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
//
// 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
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//

#ifndef BOOST_COMPUTE_LAMBDA_PLACEHOLDER_HPP
#define BOOST_COMPUTE_LAMBDA_PLACEHOLDER_HPP

namespace boost {
namespace compute {
namespace lambda {

// lambda placeholder type
template<int I>
struct placeholder
{
};

} // end lambda namespace
} // end compute namespace
} // end boost namespace

#endif // BOOST_COMPUTE_LAMBDA_PLACEHOLDER_HPP


code:
/*
  [auto_generated]
  boost/numeric/odeint/iterator/detail/n_step_iterator_impl.hpp

  [begin_description]
  tba.
  [end_description]

  Copyright 2009-2013 Karsten Ahnert
  Copyright 2009-2013 Mario Mulansky

  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_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED
#define BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED

#include <boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp>
#include <boost/numeric/odeint/util/unit_helper.hpp>

namespace boost {
namespace numeric {
namespace odeint {

    template< class Iterator , class Stepper , class System , class State , typename Tag , class StepperTag >
    class n_step_iterator_impl;

    /*
     * Specilization for steppers and error steppers
     */
    /**
     * \brief ODE Iterator performing exactly n steps with constant step size. The value type of this iterator is the state type of the stepper.
     *
     * Implements an ODE iterator solving the ODE with constant step size. Uses steppers fulfilling the Stepper concept.
     * n_step_iterator is a model of single-pass iterator.
     *
     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
     *
     * \tparam Stepper The stepper type which should be used during the iteration.
     * \tparam System The type of the system function (ODE) which should be solved.
     */
    template< class Iterator , class Stepper , class System , class State , typename Tag >
    class n_step_iterator_impl< Iterator , Stepper , System , State , Tag , stepper_tag >
        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
    {
    private:

        typedef Stepper stepper_type;
        typedef System system_type;
        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
        typedef State state_type;
        typedef typename traits::time_type< stepper_type >::type time_type;
        typedef typename traits::value_type< stepper_type >::type ode_value_type;
        #ifndef DOXYGEN_SKIP
        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
        #endif

    public:

        /**
         * \brief Constructs a n_step_iterator. This constructor should be used to construct the begin iterator.
         *
         * \param stepper The stepper to use during the iteration.
         * \param sys The system function (ODE) to solve.
         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
         * \param t The initial time.
         * \param dt The initial time step.
         * \param num_of_steps the number of steps to be executed.
         */
        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
                              time_type t , time_type dt , size_t num_of_steps )
            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
              m_steps(num_of_steps) , m_step( 0 )
        { }

        /**
         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
         *
         * \param stepper The stepper to use during the iteration.
         * \param sys The system function (ODE) to solve.
         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
         */
        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
            : base_type( stepper , sys ) , m_state( &s ) { }

    protected:

        friend class boost::iterator_core_access;

        void increment()
        {
            if( this->m_step < this->m_steps )
            {
                unwrapped_stepper_type &stepper = this->m_stepper;
                stepper.do_step( this->m_system , *this->m_state , this->m_t , this->m_dt );
                // use integer to compute current time to reduce roundoff errors
                this->m_step++;
                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
            } else {
                this->m_at_end = true;

            }
        }

    public:
        const state_type& get_state() const
        {
            return *m_state;
        }

    private:
        time_type m_t_start;
        time_type m_t_end;
        state_type* m_state;
        size_t m_steps;
        size_t m_step;

    };

    /*
     * Specilization for dense output stepper
     */
    /**
     * \brief ODE Iterator with step-size control and dense output.
     *
     * Implements an ODE iterator solving the ODE with constant steps. Uses dense-output steppers.
     * n_step_iterator is a model of single-pass iterator.
     *
     * The value type of this iterator is the state type of the stepper. Hence one can only access the state and not the current time.
     *
     * \tparam Stepper The stepper type which should be used during the iteration.
     * \tparam System The type of the system function (ODE) which should be solved.
     */
    template< class Iterator , class Stepper , class System , class State , typename Tag >
    class n_step_iterator_impl< Iterator , Stepper , System , State , Tag , dense_output_stepper_tag >
        : public detail::ode_iterator_base< Iterator , Stepper , System , State , Tag >
    {
    private:

        typedef Stepper stepper_type;
        typedef System system_type;
        typedef typename boost::numeric::odeint::unwrap_reference< stepper_type >::type unwrapped_stepper_type;
        typedef State state_type;
        typedef typename traits::time_type< stepper_type >::type time_type;
        typedef typename traits::value_type< stepper_type >::type ode_value_type;
        #ifndef DOXYGEN_SKIP
        typedef detail::ode_iterator_base< Iterator , Stepper , System , State , Tag > base_type;
        #endif

    public:

        /**
         * \brief Constructs a const_step_iterator. This constructor should be used to construct the begin iterator.
         *
         * \param stepper The stepper to use during the iteration.
         * \param sys The system function (ODE) to solve.
         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
         * \param t The initial time.
         * \param dt The initial time step.
         * \param num_of_steps the number of steps to be executed.
         */
        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s ,
                              time_type t , time_type dt , size_t num_of_steps )
            : base_type( stepper , sys , t , dt ) , m_t_start( t ) , m_state( &s ) ,
              m_steps( num_of_steps ) , m_step( 0 )
        {
            unwrapped_stepper_type &st = this->m_stepper;
            st.initialize( * ( this->m_state ) , this->m_t , this->m_dt );
        }

        /**
         * \brief Constructs a const_step_iterator. This constructor should be used to construct the end iterator.
         *
         * \param stepper The stepper to use during the iteration.
         * \param sys The system function (ODE) to solve.
         * \param s The initial state. const_step_iterator stores a reference of s and changes its value during the iteration.
         */
        n_step_iterator_impl( stepper_type stepper , system_type sys , state_type &s )
            : base_type( stepper , sys ) , m_state( &s )
        {
        }

    protected:

        friend class boost::iterator_core_access;

        void increment( void )
        {
            if( this->m_step < this->m_steps )
            {
                unwrapped_stepper_type &stepper = this->m_stepper;
                // use integer to compute current time to reduce roundoff errors
                this->m_step++;
                this->m_t = this->m_t_start + static_cast< typename unit_value_type<time_type>::type >(this->m_step)*this->m_dt;
                while( detail::less_with_sign( stepper.current_time() , this->m_t ,
                       stepper.current_time_step() ) )
                {
                    stepper.do_step( this->m_system );
                }
                stepper.calc_state( this->m_t , *( this->m_state ) );
            } else {
                this->m_at_end = true;
            }
        }

    public:
        const state_type& get_state() const
        {
            return *m_state;
        }

    private:
        time_type m_t_start;
        time_type m_t_end;
        state_type* m_state;
        size_t m_steps;
        size_t m_step;
    };

} // namespace odeint
} // namespace numeric
} // namespace boost

#endif // BOOST_NUMERIC_ODEINT_ITERATOR_DETAIL_N_STEP_ITERATOR_IMPL_HPP_DEFINED


code:
/*=============================================================================
    Copyright (c) 2001-2007 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)
==============================================================================*/
#ifndef BOOST_PHOENIX_CORE_LIMITS_HPP
#define BOOST_PHOENIX_CORE_LIMITS_HPP

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/arithmetic/add.hpp>
#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/dec.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/phoenix/version.hpp>
#include <boost/phoenix/support/preprocessor/round.hpp>

#if defined(BOOST_PHOENIX_LIMIT)
# if !defined( BOOST_PROTO_MAX_ARITY )
#  define BOOST_PROTO_MAX_ARITY BOOST_PHOENIX_LIMIT
# elif (BOOST_PROTO_MAX_ARITY < BOOST_PHOENIX_LIMIT)
#  error "BOOST_PROTO_MAX_ARITY is set too low"
# endif
#include <boost/proto/proto_fwd.hpp>
#else
#include <boost/proto/proto_fwd.hpp>
#define BOOST_PHOENIX_LIMIT BOOST_PROTO_MAX_ARITY
#endif

#if !defined(PHOENIX_LIMIT)
#define PHOENIX_LIMIT BOOST_PHOENIX_LIMIT
#endif

#define BOOST_PHOENIX_LIMIT_STR BOOST_PP_STRINGIZE(BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT))

#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
# define BOOST_PHOENIX_NO_VARIADIC_ACTOR
# define BOOST_PHOENIX_NO_VARIADIC_CALL
# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EQUAL
# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
# define BOOST_PHOENIX_NO_VARIADIC_PHX2_RESULT
# define BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
# define BOOST_PHOENIX_NO_VARIADIC_BIND
# define BOOST_PHOENIX_NO_VARIADIC_SCOPE
#endif
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
# define BOOST_PHOENIX_NO_VARIADIC_ACTOR
# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
#endif

#if BOOST_WORKAROUND(BOOST_MSVC, == 1800)
// FIXME: temporary disable on MSVC 2013.
# define BOOST_PHOENIX_NO_VARIADIC_SCOPE
#endif

#ifdef BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
// FIXME: Due to proto, some compilers cannot expand parameter pack.
# define BOOST_PHOENIX_NO_VARIADIC_ACTOR
# define BOOST_PHOENIX_NO_VARIADIC_CALL
# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION_EVAL
# define BOOST_PHOENIX_NO_VARIADIC_PHX2_RESULT
# define BOOST_PHOENIX_NO_VARIADIC_EXPRESSION
# define BOOST_PHOENIX_NO_VARIADIC_BIND
# define BOOST_PHOENIX_NO_VARIADIC_SCOPE
#endif

# define BOOST_PHOENIX_NO_VARIADIC_OBJECT
# define BOOST_PHOENIX_NO_VARIADIC_OPERATOR
# define BOOST_PHOENIX_NO_VARIADIC_FUNCTION

#if !defined(BOOST_PHOENIX_ARG_LIMIT)
# define BOOST_PHOENIX_ARG_LIMIT BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT)
#elif (BOOST_PHOENIX_ARG_LIMIT < 5)
# error "BOOST_PHOENIX_ARG_LIMIT is set too low"
#elif BOOST_PHOENIX_ARG_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_ACTOR_LIMIT)
# define BOOST_PHOENIX_ACTOR_LIMIT BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT)
#elif (BOOST_PHOENIX_ACTOR_LIMIT > BOOST_PHOENIX_ARG_LIMIT)
# error "BOOST_PHOENIX_ACTOR_LIMIT > BOOST_PHOENIX_ARG_LIMIT"
#elif (BOOST_PHOENIX_ACTOR_LIMIT < 3)
# error "BOOST_PHOENIX_ACTOR_LIMIT is set too low"
#elif BOOST_PHOENIX_ACTOR_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_PERFECT_FORWARD_LIMIT)
# define BOOST_PHOENIX_PERFECT_FORWARD_LIMIT 3
#elif (BOOST_PHOENIX_PERFECT_FORWARD_LIMIT > BOOST_PHOENIX_ACTOR_LIMIT)
# error "BOOST_PHOENIX_PERFECT_FORWARD_LIMIT > BOOST_PHOENIX_ACTOR_LIMIT"
#elif (BOOST_PHOENIX_PERFECT_FORWARD_LIMIT < 3)
# error "BOOST_PHOENIX_PERFECT_FORWARD_LIMIT is set too low"
#elif BOOST_PHOENIX_PERFECT_FORWARD_LIMIT != 3 && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_COMPOSITE_LIMIT)
# define BOOST_PHOENIX_COMPOSITE_LIMIT BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT)
#elif (BOOST_PHOENIX_COMPOSITE_LIMIT < 5)
# error "BOOST_PHOENIX_COMPOSITE_LIMIT is set too low"
#elif BOOST_PHOENIX_COMPOSITE_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_MEMBER_LIMIT)
# define BOOST_PHOENIX_MEMBER_LIMIT BOOST_PP_DEC(BOOST_PHOENIX_COMPOSITE_LIMIT)
#elif (BOOST_PHOENIX_MEMBER_LIMIT > BOOST_PHOENIX_COMPOSITE_LIMIT)
# error "BOOST_PHOENIX_MEMBER_LIMIT > BOOST_PHOENIX_COMPOSITE_LIMIT"
#elif (BOOST_PHOENIX_MEMBER_LIMIT < 3)
# error "BOOST_PHOENIX_MEMBER_LIMIT is set too low"
#elif BOOST_PHOENIX_MEMBER_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_CATCH_LIMIT)
# define BOOST_PHOENIX_CATCH_LIMIT BOOST_PHOENIX_COMPOSITE_LIMIT
#elif (BOOST_PHOENIX_CATCH_LIMIT < 1)
# error "BOOST_PHOENIX_CATCH_LIMIT is set too low"
#elif BOOST_PHOENIX_CATCH_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_DYNAMIC_LIMIT)
# define BOOST_PHOENIX_DYNAMIC_LIMIT BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT)
#elif (BOOST_PHOENIX_DYNAMIC_LIMIT < 1)
# error "BOOST_PHOENIX_DYNAMIC_LIMIT is set too low"
#elif BOOST_PHOENIX_DYNAMIC_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#if !defined(BOOST_PHOENIX_LOCAL_LIMIT)
# define BOOST_PHOENIX_LOCAL_LIMIT BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT)
#elif (BOOST_PHOENIX_LOCAL_LIMIT < 3)
# error "BOOST_PHOENIX_LOCAL_LIMIT is set too low"
#elif BOOST_PHOENIX_LOCAL_LIMIT != BOOST_PHOENIX_PP_ROUND_UP(BOOST_PHOENIX_LIMIT) && !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
# define BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES
#endif

#endif


code:
///////////////////////////////////////////////////////////////////////////////
/// \file push_back.hpp
/// Proto callables Fusion push_back
//
//  Copyright 2010 Eric Niebler. Distributed under the Boost
//  Software License, Version 1.0. (See accompanying file
//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010
#define BOOST_PROTO_FUNCTIONAL_FUSION_PUSH_BACK_HPP_EAN_11_27_2010

#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/fusion/include/push_back.hpp>
#include <boost/proto/proto_fwd.hpp>

namespace boost { namespace proto { namespace functional
{
    /// \brief A PolymorphicFunctionObject type that invokes the
    /// \c fusion::push_back() algorithm on its argument.
    ///
    /// A PolymorphicFunctionObject type that invokes the
    /// \c fusion::push_back() algorithm on its argument.
    struct push_back
    {
        BOOST_PROTO_CALLABLE()

        template<typename Sig>
        struct result;

        template<typename This, typename Seq, typename T>
        struct result<This(Seq, T)>
          : fusion::result_of::push_back<
                typename boost::add_const<typename boost::remove_reference<Seq>::type>::type
              , typename boost::remove_const<typename boost::remove_reference<T>::type>::type
            >
        {};

        template<typename Seq, typename T>
        typename fusion::result_of::push_back<Seq const, T>::type
        operator ()(Seq const &seq, T const &t) const
        {
            return fusion::push_back(seq, t);
        }
    };
}}}

#endif


code:
#!/bin/bash
"$2@CMAKE_INSTALL_SUBDIR@/@WSJTX_BUNDLE_NAME@.app/Contents/MacOS/@WSJTX_BUNDLE_NAME@" --mac-install
exit 0


code:
A basic logging facility in _WSJT-X_ saves QSO information to files
named `wsjtx.log` (in comma-separated text format) and `wsjtx_log.adi`
(in standard ADIF format).  These files can be imported directly into
other programs, for example spreadsheets and popular logging programs.
As described in the <<INSTALL,Installation>> and <<PLATFORM,Platform
Dependencies>> sections, different operating systems may place your
local log files in different locations.  You can always navigate to
them directly by selecting *Open log directory* from the *File* menu.

More elaborate logging capabilities are supported by third party
applications like {jtalert}, which can log QSOs automatically to other
applications including {hrd}, {dxlsuite}, and {log4om}.

The program option *Show DXCC entity and worked before status*
(selectable on the *Settings | General* tab) is intended mostly for
use on non-Windows platforms, where {jtalert} is not available.  When
this option is checked _WSJT-X_ appends some additional information to
all CQ messages displayed in the _Band Activity_ window.  The name of
the DXCC entity is shown, abbreviated if necessary.  Your "`worked
before`" status for this callsign (according to log file
`wsjtx_log.adi`) is flagged with a single character and a change of
background color, as follows:

[horizontal]
!::  Default color bright purple: New DXCC entity
~::  Light pink: You have already worked this DXCC entity but not
this station
 ::  Green: You have previously worked the calling station

In this respect the program does not distinguish between modes, but it
does differentiate between bands.

_WSJT-X_ includes a built-in `cty.dat` file containing DXCC prefix
information.  Updated files can be downloaded from the {cty_dat} web
site when required.  If an updated `cty.dat` is present in the logs
folder and readable, it will be used in preference to the built-in
one.

The log file `wsjtx_log.adi` is updated whenever you log a QSO from
_WSJT-X_.  (Keep in mind that if you erase this file you will lose all
"`worked before`" information.)  You can append or overwrite the
`wsjtx_log.adi` file by exporting your QSO history as an ADIF file
from another logging program.  Turning *Show DXCC entity and worked
before status* off and then on again will cause _WSJT-X_ to re-read
the log file.  Very large log files may cause _WSJT-X_ to slow down
when searching for calls.


code:
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2007-2008 Steven Watanabe
//
// 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_UNITS_CGS_GRAM_BASE_UNIT_HPP
#define BOOST_UNITS_CGS_GRAM_BASE_UNIT_HPP

#include <string>

#include <boost/units/config.hpp>
#include <boost/units/base_unit.hpp>
#include <boost/units/scaled_base_unit.hpp>
#include <boost/units/physical_dimensions/mass.hpp>

namespace boost {

namespace units {

namespace cgs {

struct gram_base_unit : public base_unit<gram_base_unit, mass_dimension, -8>
{
    static std::string name()    { return("gram"); }
    static std::string symbol() { return("g"); }
};

} // namespace cgs

} // namespace units

} // namespace boost

#if BOOST_UNITS_HAS_BOOST_TYPEOF

#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()

BOOST_TYPEOF_REGISTER_TYPE(boost::units::cgs::gram_base_unit)

#endif

//#include <boost/units/base_units/detail/conversions.hpp>

#endif // BOOST_UNITS_CGS_GRAM_BASE_UNIT_HPP


code:
#include "DisplayManual.hpp"

#include <QObject>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QUrl>
#include <QString>
#include <QDir>
#include <QFileInfo>
#include <QDesktopServices>
#include <QLocale>

#include "revision_utils.hpp"

#include "pimpl_impl.hpp"

namespace
{
  class token
    : public QObject
  {
    Q_OBJECT
  public:
    token (QUrl const& url, QString const& lang, QString const& name_we, QObject * parent = nullptr)
      : QObject {parent}
      , url_ {url}
      , lang_ {lang}
      , name_we_ {name_we}
    {
    }

    QUrl url_;
    QString lang_;
    QString name_we_;
  };
}

class DisplayManual::impl final
  : public QObject
{
  Q_OBJECT
public:
  impl (QNetworkAccessManager * qnam)
    : qnam_ {qnam}
  {
    connect (qnam_, &QNetworkAccessManager::finished, this, &DisplayManual::impl::reply_finished);
  }

  void display (QUrl const& url, QString const& name_we)
  {
    if (QNetworkAccessManager::Accessible != qnam_->networkAccessible ()) {
      // try and recover network access for QNAM
      qnam_->setNetworkAccessible (QNetworkAccessManager::Accessible);
    }

    // try and find a localized manual
    auto lang = QLocale::system ().name ();
    // try for language and country first
    auto file = name_we + '_' + lang + '-' + version () + ".html";
    auto target = url.resolved (file);
    QNetworkRequest request {target};
    request.setRawHeader ("User-Agent", "WSJT-X Manual Checker");
    request.setOriginatingObject (new token {url, lang, name_we, this});
    auto * reply = qnam_->head (request);
    outstanding_requests_ << reply;
  }

  void reply_finished (QNetworkReply * reply)
  {
    if (outstanding_requests_.contains (reply))
      {
        QUrl target;
        if (reply->error ())
          {
            if (auto * tok = qobject_cast<token *> (reply->request ().originatingObject ()))
              {
                auto pos = tok->lang_.lastIndexOf ('_');
                QString file;
                if (pos >= 0)
                  {
                    tok->lang_.truncate (pos);
                    file = tok->name_we_ + '_' + tok->lang_ + '-' + version () + ".html";
                    target = tok->url_.resolved (file);
                    QNetworkRequest request {target};
                    request.setRawHeader ("User-Agent", "WSJT-X Manual Checker");
                    request.setOriginatingObject (tok);
                    auto * reply = qnam_->head (request);
                    outstanding_requests_ << reply;
                  }
                else
                  {
                    // give up looking and request the default
                    file = tok->name_we_ + '-' + version () + ".html";
                    target = tok->url_.resolved (file);
                    QDesktopServices::openUrl (target);
                    delete tok;
                  }
              }
          }
        else
          {
            // found it
            if (auto * tok = qobject_cast<token *> (reply->request ().originatingObject ()))
              {
                delete tok;
              }
            QDesktopServices::openUrl (reply->request ().url ());
          }

        outstanding_requests_.removeOne (reply);
        reply->deleteLater ();
      }
  }

  QNetworkAccessManager * qnam_;
  QList<QNetworkReply *> outstanding_requests_;
};

#include "DisplayManual.moc"

DisplayManual::DisplayManual (QNetworkAccessManager * qnam, QObject * parent)
  : QObject {parent}
  , m_ {qnam}
{
}

DisplayManual::~DisplayManual ()
{
}

void DisplayManual::display_html_url (QUrl const& url, QString const& name_we)
{
  m_->display (url, name_we);
}

void DisplayManual::display_html_file (QDir const& dir, QString const& name_we)
{
  // try and find a localized manual
  auto lang = QLocale::system ().name ();
  // try for language and country first
  auto file = dir.absoluteFilePath (name_we + '_' + lang + '-' + version () + ".html");
  if (!QFileInfo::exists (file))
    {
      // try for language
      lang.truncate (lang.lastIndexOf ('_'));
      file = dir.absoluteFilePath (name_we + '_' + lang + '-' + version () + ".html");
      if (!QFileInfo::exists (file))
        {
          // use default
          file = dir.absoluteFilePath (name_we + '-' + version () + ".html");
        }
    }
  // may fail but browser 404 error is a good as anything
  QDesktopServices::openUrl (QUrl {"file:///" + file});
}


code:
// Copyright David Abrahams 2002.
// 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 UNWIND_TYPE_DWA200222_HPP
# define UNWIND_TYPE_DWA200222_HPP

# include <boost/python/detail/cv_category.hpp>
# include <boost/python/detail/indirect_traits.hpp>
# include <boost/type_traits/object_traits.hpp>

namespace boost { namespace python { namespace detail {

#ifndef _MSC_VER //if forward declared, msvc6.5 does not recognize them as inline
// forward declaration, required (at least) by Tru64 cxx V6.5-042
template <class Generator, class U>
inline typename Generator::result_type
unwind_type(U const& p, Generator* = 0);

// forward declaration, required (at least) by Tru64 cxx V6.5-042
template <class Generator, class U>
inline typename Generator::result_type
unwind_type(boost::type<U>*p = 0, Generator* = 0);
#endif

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U* p, cv_unqualified, Generator* = 0)
{
    return Generator::execute(p);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U const* p, const_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U volatile* p, volatile_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
{
    return unwind_type(const_cast<U*>(p), (Generator*)0);
}

template <class Generator, class U>
inline typename Generator::result_type
unwind_ptr_type(U* p, Generator* = 0)
{
    typedef typename cv_category<U>::type tag;
    return unwind_type_cv<Generator>(p, tag());
}

template <bool is_ptr>
struct unwind_helper
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U p, Generator* = 0)
    {
        return unwind_ptr_type(p, (Generator*)0);
    }
};

template <>
struct unwind_helper<false>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U& p, Generator* = 0)
    {
        return unwind_ptr_type(&p, (Generator*)0);
    }
};

template <class Generator, class U>
inline typename Generator::result_type
#ifndef _MSC_VER
unwind_type(U const& p, Generator*)
#else
unwind_type(U const& p, Generator* = 0)
#endif
{
    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
}

enum { direct_ = 0, pointer_ = 1, reference_ = 2, reference_to_pointer_ = 3 };
template <int indirection> struct unwind_helper2;

template <>
struct unwind_helper2<direct_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<pointer_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U*(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<reference_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U&(*)(), Generator* = 0)
    {
        return unwind_ptr_type((U*)0, (Generator*)0);
    }
};

template <>
struct unwind_helper2<reference_to_pointer_>
{
    template <class Generator, class U>
    static typename Generator::result_type
    execute(U&(*)(), Generator* = 0)
    {
        return unwind_ptr_type(U(0), (Generator*)0);
    }
};

// Call this one with both template parameters explicitly specified
// and no function arguments:
//
//      return unwind_type<my_generator,T>();
//
// Doesn't work if T is an array type; we could handle that case, but
// why bother?
template <class Generator, class U>
inline typename Generator::result_type
#ifndef _MSC_VER
unwind_type(boost::type<U>*, Generator*)
#else
unwind_type(boost::type<U>*p =0, Generator* =0)
#endif
{
    BOOST_STATIC_CONSTANT(int, indirection
        = (boost::is_pointer<U>::value ? pointer_ : 0)
                             + (indirect_traits::is_reference_to_pointer<U>::value
                             ? reference_to_pointer_
                             : boost::is_reference<U>::value
                             ? reference_
                             : 0));

    return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
}

}}} // namespace boost::python::detail

#endif // UNWIND_TYPE_DWA200222_HPP