code:
/*=============================================================================
    Copyright (c) 1998-2003 Joel de Guzman
    Copyright (c) 2001 Daniel Nuffer
    Copyright (c) 2002 Hartmut Kaiser
    http://spirit.sourceforge.net/

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(BOOST_SPIRIT_KLEENE_STAR_IPP)
#define BOOST_SPIRIT_KLEENE_STAR_IPP

namespace boost { namespace spirit {

BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN

    ///////////////////////////////////////////////////////////////////////////
    //
    //  kleene_star class implementation
    //
    ///////////////////////////////////////////////////////////////////////////
    template <typename S>
    inline kleene_star<S>
    operator*(parser<S> const& a)
    {
        return kleene_star<S>(a.derived());
    }

BOOST_SPIRIT_CLASSIC_NAMESPACE_END

}} // namespace boost::spirit

#endif

license: mit


code:
#ifndef BOOST_THREAD_THREAD_ONLY_HPP
#define BOOST_THREAD_THREAD_ONLY_HPP

//  thread.hpp
//
//  (C) Copyright 2013 Vicente J. Botet Escriba
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <boost/thread/detail/platform.hpp>

#if defined(BOOST_THREAD_PLATFORM_WIN32)
#include <boost/thread/win32/thread_data.hpp>
#elif defined(BOOST_THREAD_PLATFORM_PTHREAD)
#include <boost/thread/pthread/thread_data.hpp>
#else
#error "Boost threads unavailable on this platform"
#endif

#include <boost/thread/detail/thread.hpp>
#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
#include <boost/thread/detail/thread_interruption.hpp>
#endif
#include <boost/thread/v2/thread.hpp>

#endif


code:
//  (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000-2005.
//  Use, modification and distribution are subject to 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/libs/type_traits for most recent version including documentation.

#ifndef BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED
#define BOOST_TT_REMOVE_EXTENT_HPP_INCLUDED

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <cstddef> // size_t

namespace boost {

template <class T> struct remove_extent{ typedef T type; };

#if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type; };
template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) && !defined(__IBMCPP__) &&  !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840))
template <typename T> struct remove_extent<T[]> { typedef T type; };
template <typename T> struct remove_extent<T const[]> { typedef T const type; };
template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };
template <typename T> struct remove_extent<T const volatile[]> { typedef T const volatile type; };
#endif
#endif

} // namespace boost

#endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED


code:
/*=============================================================================
    Copyright (c) 2011 Eric Niebler

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

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/algorithm/iteration/fold_fwd.hpp>
#include <boost/fusion/support/segmented_fold_until.hpp>
#include <boost/mpl/bool.hpp>

namespace boost { namespace fusion { namespace detail
{
    template <typename Fun>
    struct segmented_fold_fun
    {
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        explicit segmented_fold_fun(Fun const& f)
          : fun(f)
        {}

        Fun const& fun;

        template <typename Sequence, typename State, typename Context>
        struct apply
        {
            typedef typename result_of::fold<Sequence, State, Fun>::type type;
            typedef mpl::true_ continue_type;

            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
            static type call(Sequence& seq, State const& state, Context const&, segmented_fold_fun const& fun)
            {
                return fusion::fold(seq, state, fun.fun);
            }
        };
    };

    // The default implementation of this lives in detail/fold.hpp
    template <typename Sequence, typename State, typename Fun, bool IsSequence, bool IsSegmented>
    struct result_of_fold;

    template <typename Sequence, typename State, typename Fun>
    struct result_of_fold<Sequence, State, Fun, true, true>
    {
        typedef
            typename result_of::segmented_fold_until<
                Sequence,
                State,
                segmented_fold_fun<Fun>
            >::type
        type;

        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        static type call(Sequence& seq, State& state, Fun& fun)
        {
            return fusion::segmented_fold_until(seq, state, segmented_fold_fun<Fun>(fun));
        }
    };
}}}

#endif


code:
//  boost/chrono/thread_clock.hpp  -----------------------------------------------------------//

//  Copyright 2009-2011 Vicente J. Botet Escriba

//  Distributed under the Boost Software License, Version 1.0.
//  See http://www.boost.org/LICENSE_1_0.txt

//  See http://www.boost.org/libs/system for documentation.

#include <boost/chrono/config.hpp>

#ifndef BOOST_CHRONO_THREAD_CLOCK_HPP
#define BOOST_CHRONO_THREAD_CLOCK_HPP

#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)

#include <boost/chrono/config.hpp>
#include <boost/chrono/duration.hpp>
#include <boost/chrono/time_point.hpp>
#include <boost/chrono/detail/system.hpp>
#include <boost/chrono/clock_string.hpp>

#ifndef BOOST_CHRONO_HEADER_ONLY
#include <boost/config/abi_prefix.hpp> // must be the last #include
#endif

namespace boost { namespace chrono {

class BOOST_CHRONO_DECL thread_clock {
public:
    typedef nanoseconds                          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<thread_clock>    time_point;
    BOOST_STATIC_CONSTEXPR bool is_steady =             BOOST_CHRONO_THREAD_CLOCK_IS_STEADY;

    static BOOST_CHRONO_INLINE time_point now( ) BOOST_NOEXCEPT;
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
    static BOOST_CHRONO_INLINE time_point now( system::error_code & ec );
#endif
};

template <class CharT>
struct clock_string<thread_clock, CharT>
{
  static std::basic_string<CharT> name()
  {
    static const CharT u[] =
    { 't', 'h', 'r', 'e', 'a', 'd', '_',
      'c', 'l','o', 'c', 'k'};
    static const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
    return str;
  }
  static std::basic_string<CharT> since()
  {
    const CharT u[] =
    { ' ', 's', 'i', 'n', 'c', 'e', ' ', 't', 'h', 'r', 'e', 'a', 'd', ' ', 's', 't', 'a', 'r', 't', '-', 'u', 'p'};
    const std::basic_string<CharT> str(u, u + sizeof(u)/sizeof(u[0]));
    return str;
  }
};

} // namespace chrono
} // namespace boost

#ifndef BOOST_CHRONO_HEADER_ONLY
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
#else
#include <boost/chrono/detail/inlined/thread_clock.hpp>
#endif

#endif

#endif  // BOOST_CHRONO_THREAD_CLOCK_HPP


code:
/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman

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

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/iterator/deref.hpp>
#include <boost/fusion/iterator/prior.hpp>

namespace boost { namespace fusion
{
    struct reverse_view_iterator_tag;

    namespace extension
    {
        template <typename Tag>
        struct deref_impl;

        template <>
        struct deref_impl<reverse_view_iterator_tag>
        {
            template <typename Iterator>
            struct apply
            {
                typedef typename
                    result_of::deref<
                        typename result_of::prior<
                            typename Iterator::first_type
                        >::type
                    >::type
                type;

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
                call(Iterator const& i)
                {
                    return *fusion::prior(i.first);
                }
            };
        };
    }
}}

#endif


code:
//  Boost string_algo library compare.hpp header file  -------------------------//

//  Copyright Pavol Droba 2002-2006.
//
// 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 updates, documentation, and revision history.

#ifndef BOOST_STRING_COMPARE_HPP
#define BOOST_STRING_COMPARE_HPP

#include <boost/algorithm/string/config.hpp>
#include <locale>

/*! \file
    Defines element comparison predicates. Many algorithms in this library can
    take an additional argument with a predicate used to compare elements.
    This makes it possible, for instance, to have case insensitive versions
    of the algorithms.
*/

namespace boost {
    namespace algorithm {

        //  is_equal functor  -----------------------------------------------//

        //! is_equal functor
        /*!
            Standard STL equal_to only handle comparison between arguments
            of the same type. This is a less restrictive version which wraps operator ==.
        */
        struct is_equal
        {
            //! Function operator
            /*!
                Compare two operands for equality
            */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1==Arg2;
            }
        };

        //! case insensitive version of is_equal
        /*!
            Case insensitive comparison predicate. Comparison is done using
            specified locales.
        */
        struct is_iequal
        {
            //! Constructor
            /*!
                \param Loc locales used for comparison
            */
            is_iequal( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}

            //! Function operator
            /*!
                Compare two operands. Case is ignored.
            */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)==std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
                #endif
            }

        private:
            std::locale m_Loc;
        };

        //  is_less functor  -----------------------------------------------//

        //! is_less functor
        /*!
            Convenient version of standard std::less. Operation is templated, therefore it is
            not required to specify the exact types upon the construction
         */
        struct is_less
        {
            //! Functor operation
            /*!
                Compare two operands using > operator
             */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<Arg2;
            }
        };

        //! case insensitive version of is_less
        /*!
            Case insensitive comparison predicate. Comparison is done using
            specified locales.
        */
        struct is_iless
        {
            //! Constructor
            /*!
                \param Loc locales used for comparison
            */
            is_iless( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}

            //! Function operator
            /*!
                Compare two operands. Case is ignored.
            */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)<std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
                #endif
            }

        private:
            std::locale m_Loc;
        };

        //  is_not_greater functor  -----------------------------------------------//

        //! is_not_greater functor
        /*!
            Convenient version of standard std::not_greater_to. Operation is templated, therefore it is
            not required to specify the exact types upon the construction
         */
        struct is_not_greater
        {
            //! Functor operation
            /*!
                Compare two operands using > operator
             */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<=Arg2;
            }
        };

        //! case insensitive version of is_not_greater
        /*!
            Case insensitive comparison predicate. Comparison is done using
            specified locales.
        */
        struct is_not_igreater
        {
            //! Constructor
            /*!
                \param Loc locales used for comparison
            */
            is_not_igreater( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}

            //! Function operator
            /*!
                Compare two operands. Case is ignored.
            */
            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
                    return std::toupper(Arg1)<=std::toupper(Arg2);
                #else
                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
                #endif
            }

        private:
            std::locale m_Loc;
        };

    } // namespace algorithm

    // pull names to the boost namespace
    using algorithm::is_equal;
    using algorithm::is_iequal;
    using algorithm::is_less;
    using algorithm::is_iless;
    using algorithm::is_not_greater;
    using algorithm::is_not_igreater;

} // namespace boost

#endif  // BOOST_STRING_COMPARE_HPP


code:
/*
Copyright Rene Rivera 2008-2015
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_PREDEF_OS_QNXNTO_H
#define BOOST_PREDEF_OS_QNXNTO_H

#include <boost/predef/version_number.h>
#include <boost/predef/make.h>

/*`
[heading `BOOST_OS_QNX`]

[@http://en.wikipedia.org/wiki/QNX QNX] operating system.
Version number available as major, and minor if possible. And
version 4 is specifically detected.

[table
    [[__predef_symbol__] [__predef_version__]]

    [[`__QNX__`] [__predef_detection__]]
    [[`__QNXNTO__`] [__predef_detection__]]

    [[`_NTO_VERSION`] [V.R.0]]
    [[`__QNX__`] [4.0.0]]
    ]
 */

#define BOOST_OS_QNX BOOST_VERSION_NUMBER_NOT_AVAILABLE

#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
    defined(__QNX__) || defined(__QNXNTO__) \
    )
#   undef BOOST_OS_QNX
#   if !defined(BOOST_OS_QNX) && defined(_NTO_VERSION)
#       define BOOST_OS_QNX BOOST_PREDEF_MAKE_10_VVRR(_NTO_VERSION)
#   endif
#   if !defined(BOOST_OS_QNX) && defined(__QNX__)
#       define BOOST_OS_QNX BOOST_VERSION_NUMBER(4,0,0)
#   endif
#   if !defined(BOOST_OS_QNX)
#       define BOOST_OS_QNX BOOST_VERSION_NUMBER_AVAILABLE
#   endif
#endif

#if BOOST_OS_QNX
#   define BOOST_OS_QNX_AVAILABLE
#   include <boost/predef/detail/os_detected.h>
#endif

#define BOOST_OS_QNX_NAME "QNX"

#endif

#include <boost/predef/detail/test.h>
BOOST_PREDEF_DECLARE_TEST(BOOST_OS_QNX,BOOST_OS_QNX_NAME)


code:
// Copyright (C) 2010 Peder Holt
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_TYPEOF_UNSUPPORTED_HPP_INCLUDED
#define BOOST_TYPEOF_UNSUPPORTED_HPP_INCLUDED

namespace boost { namespace type_of {
    struct typeof_emulation_is_unsupported_on_this_compiler {};
}}

#define BOOST_TYPEOF(expr) boost::type_of::typeof_emulation_is_unsupported_on_this_compiler
#define BOOST_TYPEOF_TPL BOOST_TYPEOF

#define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
struct name {\
    typedef BOOST_TYPEOF_TPL(expr) type;\
};

#define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
struct name {\
    typedef BOOST_TYPEOF(expr) type;\
};

#define BOOST_TYPEOF_REGISTER_TYPE(x)
#define BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)

#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 !defined(BOOST_PP_LOCAL_LIMITS)
#    error BOOST_PP_ERROR:  local iteration boundaries are not defined
# elif !defined(BOOST_PP_LOCAL_MACRO)
#    error BOOST_PP_ERROR:  local iteration target macro is not defined
# else
#    if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
#        define BOOST_PP_LOCAL_S BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS)
#        define BOOST_PP_LOCAL_F BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS)
#    else
#        define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS)
#        include <boost/preprocessor/iteration/detail/start.hpp>
#        define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS)
#        include <boost/preprocessor/iteration/detail/finish.hpp>
#        define BOOST_PP_LOCAL_S BOOST_PP_LOCAL_SE()
#        define BOOST_PP_LOCAL_F BOOST_PP_LOCAL_FE()
#    endif
# endif
#
# if (BOOST_PP_LOCAL_S) > (BOOST_PP_LOCAL_F)
#    include <boost/preprocessor/iteration/detail/rlocal.hpp>
# else
#    if BOOST_PP_LOCAL_C(0)
        BOOST_PP_LOCAL_MACRO(0)
#    endif
#    if BOOST_PP_LOCAL_C(1)
        BOOST_PP_LOCAL_MACRO(1)
#    endif
#    if BOOST_PP_LOCAL_C(2)
        BOOST_PP_LOCAL_MACRO(2)
#    endif
#    if BOOST_PP_LOCAL_C(3)
        BOOST_PP_LOCAL_MACRO(3)
#    endif
#    if BOOST_PP_LOCAL_C(4)
        BOOST_PP_LOCAL_MACRO(4)
#    endif
#    if BOOST_PP_LOCAL_C(5)
        BOOST_PP_LOCAL_MACRO(5)
#    endif
#    if BOOST_PP_LOCAL_C(6)
        BOOST_PP_LOCAL_MACRO(6)
#    endif
#    if BOOST_PP_LOCAL_C(7)
        BOOST_PP_LOCAL_MACRO(7)
#    endif
#    if BOOST_PP_LOCAL_C(8)
        BOOST_PP_LOCAL_MACRO(8)
#    endif
#    if BOOST_PP_LOCAL_C(9)
        BOOST_PP_LOCAL_MACRO(9)
#    endif
#    if BOOST_PP_LOCAL_C(10)
        BOOST_PP_LOCAL_MACRO(10)
#    endif
#    if BOOST_PP_LOCAL_C(11)
        BOOST_PP_LOCAL_MACRO(11)
#    endif
#    if BOOST_PP_LOCAL_C(12)
        BOOST_PP_LOCAL_MACRO(12)
#    endif
#    if BOOST_PP_LOCAL_C(13)
        BOOST_PP_LOCAL_MACRO(13)
#    endif
#    if BOOST_PP_LOCAL_C(14)
        BOOST_PP_LOCAL_MACRO(14)
#    endif
#    if BOOST_PP_LOCAL_C(15)
        BOOST_PP_LOCAL_MACRO(15)
#    endif
#    if BOOST_PP_LOCAL_C(16)
        BOOST_PP_LOCAL_MACRO(16)
#    endif
#    if BOOST_PP_LOCAL_C(17)
        BOOST_PP_LOCAL_MACRO(17)
#    endif
#    if BOOST_PP_LOCAL_C(18)
        BOOST_PP_LOCAL_MACRO(18)
#    endif
#    if BOOST_PP_LOCAL_C(19)
        BOOST_PP_LOCAL_MACRO(19)
#    endif
#    if BOOST_PP_LOCAL_C(20)
        BOOST_PP_LOCAL_MACRO(20)
#    endif
#    if BOOST_PP_LOCAL_C(21)
        BOOST_PP_LOCAL_MACRO(21)
#    endif
#    if BOOST_PP_LOCAL_C(22)
        BOOST_PP_LOCAL_MACRO(22)
#    endif
#    if BOOST_PP_LOCAL_C(23)
        BOOST_PP_LOCAL_MACRO(23)
#    endif
#    if BOOST_PP_LOCAL_C(24)
        BOOST_PP_LOCAL_MACRO(24)
#    endif
#    if BOOST_PP_LOCAL_C(25)
        BOOST_PP_LOCAL_MACRO(25)
#    endif
#    if BOOST_PP_LOCAL_C(26)
        BOOST_PP_LOCAL_MACRO(26)
#    endif
#    if BOOST_PP_LOCAL_C(27)
        BOOST_PP_LOCAL_MACRO(27)
#    endif
#    if BOOST_PP_LOCAL_C(28)
        BOOST_PP_LOCAL_MACRO(28)
#    endif
#    if BOOST_PP_LOCAL_C(29)
        BOOST_PP_LOCAL_MACRO(29)
#    endif
#    if BOOST_PP_LOCAL_C(30)
        BOOST_PP_LOCAL_MACRO(30)
#    endif
#    if BOOST_PP_LOCAL_C(31)
        BOOST_PP_LOCAL_MACRO(31)
#    endif
#    if BOOST_PP_LOCAL_C(32)
        BOOST_PP_LOCAL_MACRO(32)
#    endif
#    if BOOST_PP_LOCAL_C(33)
        BOOST_PP_LOCAL_MACRO(33)
#    endif
#    if BOOST_PP_LOCAL_C(34)
        BOOST_PP_LOCAL_MACRO(34)
#    endif
#    if BOOST_PP_LOCAL_C(35)
        BOOST_PP_LOCAL_MACRO(35)
#    endif
#    if BOOST_PP_LOCAL_C(36)
        BOOST_PP_LOCAL_MACRO(36)
#    endif
#    if BOOST_PP_LOCAL_C(37)
        BOOST_PP_LOCAL_MACRO(37)
#    endif
#    if BOOST_PP_LOCAL_C(38)
        BOOST_PP_LOCAL_MACRO(38)
#    endif
#    if BOOST_PP_LOCAL_C(39)
        BOOST_PP_LOCAL_MACRO(39)
#    endif
#    if BOOST_PP_LOCAL_C(40)
        BOOST_PP_LOCAL_MACRO(40)
#    endif
#    if BOOST_PP_LOCAL_C(41)
        BOOST_PP_LOCAL_MACRO(41)
#    endif
#    if BOOST_PP_LOCAL_C(42)
        BOOST_PP_LOCAL_MACRO(42)
#    endif
#    if BOOST_PP_LOCAL_C(43)
        BOOST_PP_LOCAL_MACRO(43)
#    endif
#    if BOOST_PP_LOCAL_C(44)
        BOOST_PP_LOCAL_MACRO(44)
#    endif
#    if BOOST_PP_LOCAL_C(45)
        BOOST_PP_LOCAL_MACRO(45)
#    endif
#    if BOOST_PP_LOCAL_C(46)
        BOOST_PP_LOCAL_MACRO(46)
#    endif
#    if BOOST_PP_LOCAL_C(47)
        BOOST_PP_LOCAL_MACRO(47)
#    endif
#    if BOOST_PP_LOCAL_C(48)
        BOOST_PP_LOCAL_MACRO(48)
#    endif
#    if BOOST_PP_LOCAL_C(49)
        BOOST_PP_LOCAL_MACRO(49)
#    endif
#    if BOOST_PP_LOCAL_C(50)
        BOOST_PP_LOCAL_MACRO(50)
#    endif
#    if BOOST_PP_LOCAL_C(51)
        BOOST_PP_LOCAL_MACRO(51)
#    endif
#    if BOOST_PP_LOCAL_C(52)
        BOOST_PP_LOCAL_MACRO(52)
#    endif
#    if BOOST_PP_LOCAL_C(53)
        BOOST_PP_LOCAL_MACRO(53)
#    endif
#    if BOOST_PP_LOCAL_C(54)
        BOOST_PP_LOCAL_MACRO(54)
#    endif
#    if BOOST_PP_LOCAL_C(55)
        BOOST_PP_LOCAL_MACRO(55)
#    endif
#    if BOOST_PP_LOCAL_C(56)
        BOOST_PP_LOCAL_MACRO(56)
#    endif
#    if BOOST_PP_LOCAL_C(57)
        BOOST_PP_LOCAL_MACRO(57)
#    endif
#    if BOOST_PP_LOCAL_C(58)
        BOOST_PP_LOCAL_MACRO(58)
#    endif
#    if BOOST_PP_LOCAL_C(59)
        BOOST_PP_LOCAL_MACRO(59)
#    endif
#    if BOOST_PP_LOCAL_C(60)
        BOOST_PP_LOCAL_MACRO(60)
#    endif
#    if BOOST_PP_LOCAL_C(61)
        BOOST_PP_LOCAL_MACRO(61)
#    endif
#    if BOOST_PP_LOCAL_C(62)
        BOOST_PP_LOCAL_MACRO(62)
#    endif
#    if BOOST_PP_LOCAL_C(63)
        BOOST_PP_LOCAL_MACRO(63)
#    endif
#    if BOOST_PP_LOCAL_C(64)
        BOOST_PP_LOCAL_MACRO(64)
#    endif
#    if BOOST_PP_LOCAL_C(65)
        BOOST_PP_LOCAL_MACRO(65)
#    endif
#    if BOOST_PP_LOCAL_C(66)
        BOOST_PP_LOCAL_MACRO(66)
#    endif
#    if BOOST_PP_LOCAL_C(67)
        BOOST_PP_LOCAL_MACRO(67)
#    endif
#    if BOOST_PP_LOCAL_C(68)
        BOOST_PP_LOCAL_MACRO(68)
#    endif
#    if BOOST_PP_LOCAL_C(69)
        BOOST_PP_LOCAL_MACRO(69)
#    endif
#    if BOOST_PP_LOCAL_C(70)
        BOOST_PP_LOCAL_MACRO(70)
#    endif
#    if BOOST_PP_LOCAL_C(71)
        BOOST_PP_LOCAL_MACRO(71)
#    endif
#    if BOOST_PP_LOCAL_C(72)
        BOOST_PP_LOCAL_MACRO(72)
#    endif
#    if BOOST_PP_LOCAL_C(73)
        BOOST_PP_LOCAL_MACRO(73)
#    endif
#    if BOOST_PP_LOCAL_C(74)
        BOOST_PP_LOCAL_MACRO(74)
#    endif
#    if BOOST_PP_LOCAL_C(75)
        BOOST_PP_LOCAL_MACRO(75)
#    endif
#    if BOOST_PP_LOCAL_C(76)
        BOOST_PP_LOCAL_MACRO(76)
#    endif
#    if BOOST_PP_LOCAL_C(77)
        BOOST_PP_LOCAL_MACRO(77)
#    endif
#    if BOOST_PP_LOCAL_C(78)
        BOOST_PP_LOCAL_MACRO(78)
#    endif
#    if BOOST_PP_LOCAL_C(79)
        BOOST_PP_LOCAL_MACRO(79)
#    endif
#    if BOOST_PP_LOCAL_C(80)
        BOOST_PP_LOCAL_MACRO(80)
#    endif
#    if BOOST_PP_LOCAL_C(81)
        BOOST_PP_LOCAL_MACRO(81)
#    endif
#    if BOOST_PP_LOCAL_C(82)
        BOOST_PP_LOCAL_MACRO(82)
#    endif
#    if BOOST_PP_LOCAL_C(83)
        BOOST_PP_LOCAL_MACRO(83)
#    endif
#    if BOOST_PP_LOCAL_C(84)
        BOOST_PP_LOCAL_MACRO(84)
#    endif
#    if BOOST_PP_LOCAL_C(85)
        BOOST_PP_LOCAL_MACRO(85)
#    endif
#    if BOOST_PP_LOCAL_C(86)
        BOOST_PP_LOCAL_MACRO(86)
#    endif
#    if BOOST_PP_LOCAL_C(87)
        BOOST_PP_LOCAL_MACRO(87)
#    endif
#    if BOOST_PP_LOCAL_C(88)
        BOOST_PP_LOCAL_MACRO(88)
#    endif
#    if BOOST_PP_LOCAL_C(89)
        BOOST_PP_LOCAL_MACRO(89)
#    endif
#    if BOOST_PP_LOCAL_C(90)
        BOOST_PP_LOCAL_MACRO(90)
#    endif
#    if BOOST_PP_LOCAL_C(91)
        BOOST_PP_LOCAL_MACRO(91)
#    endif
#    if BOOST_PP_LOCAL_C(92)
        BOOST_PP_LOCAL_MACRO(92)
#    endif
#    if BOOST_PP_LOCAL_C(93)
        BOOST_PP_LOCAL_MACRO(93)
#    endif
#    if BOOST_PP_LOCAL_C(94)
        BOOST_PP_LOCAL_MACRO(94)
#    endif
#    if BOOST_PP_LOCAL_C(95)
        BOOST_PP_LOCAL_MACRO(95)
#    endif
#    if BOOST_PP_LOCAL_C(96)
        BOOST_PP_LOCAL_MACRO(96)
#    endif
#    if BOOST_PP_LOCAL_C(97)
        BOOST_PP_LOCAL_MACRO(97)
#    endif
#    if BOOST_PP_LOCAL_C(98)
        BOOST_PP_LOCAL_MACRO(98)
#    endif
#    if BOOST_PP_LOCAL_C(99)
        BOOST_PP_LOCAL_MACRO(99)
#    endif
#    if BOOST_PP_LOCAL_C(100)
        BOOST_PP_LOCAL_MACRO(100)
#    endif
#    if BOOST_PP_LOCAL_C(101)
        BOOST_PP_LOCAL_MACRO(101)
#    endif
#    if BOOST_PP_LOCAL_C(102)
        BOOST_PP_LOCAL_MACRO(102)
#    endif
#    if BOOST_PP_LOCAL_C(103)
        BOOST_PP_LOCAL_MACRO(103)
#    endif
#    if BOOST_PP_LOCAL_C(104)
        BOOST_PP_LOCAL_MACRO(104)
#    endif
#    if BOOST_PP_LOCAL_C(105)
        BOOST_PP_LOCAL_MACRO(105)
#    endif
#    if BOOST_PP_LOCAL_C(106)
        BOOST_PP_LOCAL_MACRO(106)
#    endif
#    if BOOST_PP_LOCAL_C(107)
        BOOST_PP_LOCAL_MACRO(107)
#    endif
#    if BOOST_PP_LOCAL_C(108)
        BOOST_PP_LOCAL_MACRO(108)
#    endif
#    if BOOST_PP_LOCAL_C(109)
        BOOST_PP_LOCAL_MACRO(109)
#    endif
#    if BOOST_PP_LOCAL_C(110)
        BOOST_PP_LOCAL_MACRO(110)
#    endif
#    if BOOST_PP_LOCAL_C(111)
        BOOST_PP_LOCAL_MACRO(111)
#    endif
#    if BOOST_PP_LOCAL_C(112)
        BOOST_PP_LOCAL_MACRO(112)
#    endif
#    if BOOST_PP_LOCAL_C(113)
        BOOST_PP_LOCAL_MACRO(113)
#    endif
#    if BOOST_PP_LOCAL_C(114)
        BOOST_PP_LOCAL_MACRO(114)
#    endif
#    if BOOST_PP_LOCAL_C(115)
        BOOST_PP_LOCAL_MACRO(115)
#    endif
#    if BOOST_PP_LOCAL_C(116)
        BOOST_PP_LOCAL_MACRO(116)
#    endif
#    if BOOST_PP_LOCAL_C(117)
        BOOST_PP_LOCAL_MACRO(117)
#    endif
#    if BOOST_PP_LOCAL_C(118)
        BOOST_PP_LOCAL_MACRO(118)
#    endif
#    if BOOST_PP_LOCAL_C(119)
        BOOST_PP_LOCAL_MACRO(119)
#    endif
#    if BOOST_PP_LOCAL_C(120)
        BOOST_PP_LOCAL_MACRO(120)
#    endif
#    if BOOST_PP_LOCAL_C(121)
        BOOST_PP_LOCAL_MACRO(121)
#    endif
#    if BOOST_PP_LOCAL_C(122)
        BOOST_PP_LOCAL_MACRO(122)
#    endif
#    if BOOST_PP_LOCAL_C(123)
        BOOST_PP_LOCAL_MACRO(123)
#    endif
#    if BOOST_PP_LOCAL_C(124)
        BOOST_PP_LOCAL_MACRO(124)
#    endif
#    if BOOST_PP_LOCAL_C(125)
        BOOST_PP_LOCAL_MACRO(125)
#    endif
#    if BOOST_PP_LOCAL_C(126)
        BOOST_PP_LOCAL_MACRO(126)
#    endif
#    if BOOST_PP_LOCAL_C(127)
        BOOST_PP_LOCAL_MACRO(127)
#    endif
#    if BOOST_PP_LOCAL_C(128)
        BOOST_PP_LOCAL_MACRO(128)
#    endif
#    if BOOST_PP_LOCAL_C(129)
        BOOST_PP_LOCAL_MACRO(129)
#    endif
#    if BOOST_PP_LOCAL_C(130)
        BOOST_PP_LOCAL_MACRO(130)
#    endif
#    if BOOST_PP_LOCAL_C(131)
        BOOST_PP_LOCAL_MACRO(131)
#    endif
#    if BOOST_PP_LOCAL_C(132)
        BOOST_PP_LOCAL_MACRO(132)
#    endif
#    if BOOST_PP_LOCAL_C(133)
        BOOST_PP_LOCAL_MACRO(133)
#    endif
#    if BOOST_PP_LOCAL_C(134)
        BOOST_PP_LOCAL_MACRO(134)
#    endif
#    if BOOST_PP_LOCAL_C(135)
        BOOST_PP_LOCAL_MACRO(135)
#    endif
#    if BOOST_PP_LOCAL_C(136)
        BOOST_PP_LOCAL_MACRO(136)
#    endif
#    if BOOST_PP_LOCAL_C(137)
        BOOST_PP_LOCAL_MACRO(137)
#    endif
#    if BOOST_PP_LOCAL_C(138)
        BOOST_PP_LOCAL_MACRO(138)
#    endif
#    if BOOST_PP_LOCAL_C(139)
        BOOST_PP_LOCAL_MACRO(139)
#    endif
#    if BOOST_PP_LOCAL_C(140)
        BOOST_PP_LOCAL_MACRO(140)
#    endif
#    if BOOST_PP_LOCAL_C(141)
        BOOST_PP_LOCAL_MACRO(141)
#    endif
#    if BOOST_PP_LOCAL_C(142)
        BOOST_PP_LOCAL_MACRO(142)
#    endif
#    if BOOST_PP_LOCAL_C(143)
        BOOST_PP_LOCAL_MACRO(143)
#    endif
#    if BOOST_PP_LOCAL_C(144)
        BOOST_PP_LOCAL_MACRO(144)
#    endif
#    if BOOST_PP_LOCAL_C(145)
        BOOST_PP_LOCAL_MACRO(145)
#    endif
#    if BOOST_PP_LOCAL_C(146)
        BOOST_PP_LOCAL_MACRO(146)
#    endif
#    if BOOST_PP_LOCAL_C(147)
        BOOST_PP_LOCAL_MACRO(147)
#    endif
#    if BOOST_PP_LOCAL_C(148)
        BOOST_PP_LOCAL_MACRO(148)
#    endif
#    if BOOST_PP_LOCAL_C(149)
        BOOST_PP_LOCAL_MACRO(149)
#    endif
#    if BOOST_PP_LOCAL_C(150)
        BOOST_PP_LOCAL_MACRO(150)
#    endif
#    if BOOST_PP_LOCAL_C(151)
        BOOST_PP_LOCAL_MACRO(151)
#    endif
#    if BOOST_PP_LOCAL_C(152)
        BOOST_PP_LOCAL_MACRO(152)
#    endif
#    if BOOST_PP_LOCAL_C(153)
        BOOST_PP_LOCAL_MACRO(153)
#    endif
#    if BOOST_PP_LOCAL_C(154)
        BOOST_PP_LOCAL_MACRO(154)
#    endif
#    if BOOST_PP_LOCAL_C(155)
        BOOST_PP_LOCAL_MACRO(155)
#    endif
#    if BOOST_PP_LOCAL_C(156)
        BOOST_PP_LOCAL_MACRO(156)
#    endif
#    if BOOST_PP_LOCAL_C(157)
        BOOST_PP_LOCAL_MACRO(157)
#    endif
#    if BOOST_PP_LOCAL_C(158)
        BOOST_PP_LOCAL_MACRO(158)
#    endif
#    if BOOST_PP_LOCAL_C(159)
        BOOST_PP_LOCAL_MACRO(159)
#    endif
#    if BOOST_PP_LOCAL_C(160)
        BOOST_PP_LOCAL_MACRO(160)
#    endif
#    if BOOST_PP_LOCAL_C(161)
        BOOST_PP_LOCAL_MACRO(161)
#    endif
#    if BOOST_PP_LOCAL_C(162)
        BOOST_PP_LOCAL_MACRO(162)
#    endif
#    if BOOST_PP_LOCAL_C(163)
        BOOST_PP_LOCAL_MACRO(163)
#    endif
#    if BOOST_PP_LOCAL_C(164)
        BOOST_PP_LOCAL_MACRO(164)
#    endif
#    if BOOST_PP_LOCAL_C(165)
        BOOST_PP_LOCAL_MACRO(165)
#    endif
#    if BOOST_PP_LOCAL_C(166)
        BOOST_PP_LOCAL_MACRO(166)
#    endif
#    if BOOST_PP_LOCAL_C(167)
        BOOST_PP_LOCAL_MACRO(167)
#    endif
#    if BOOST_PP_LOCAL_C(168)
        BOOST_PP_LOCAL_MACRO(168)
#    endif
#    if BOOST_PP_LOCAL_C(169)
        BOOST_PP_LOCAL_MACRO(169)
#    endif
#    if BOOST_PP_LOCAL_C(170)
        BOOST_PP_LOCAL_MACRO(170)
#    endif
#    if BOOST_PP_LOCAL_C(171)
        BOOST_PP_LOCAL_MACRO(171)
#    endif
#    if BOOST_PP_LOCAL_C(172)
        BOOST_PP_LOCAL_MACRO(172)
#    endif
#    if BOOST_PP_LOCAL_C(173)
        BOOST_PP_LOCAL_MACRO(173)
#    endif
#    if BOOST_PP_LOCAL_C(174)
        BOOST_PP_LOCAL_MACRO(174)
#    endif
#    if BOOST_PP_LOCAL_C(175)
        BOOST_PP_LOCAL_MACRO(175)
#    endif
#    if BOOST_PP_LOCAL_C(176)
        BOOST_PP_LOCAL_MACRO(176)
#    endif
#    if BOOST_PP_LOCAL_C(177)
        BOOST_PP_LOCAL_MACRO(177)
#    endif
#    if BOOST_PP_LOCAL_C(178)
        BOOST_PP_LOCAL_MACRO(178)
#    endif
#    if BOOST_PP_LOCAL_C(179)
        BOOST_PP_LOCAL_MACRO(179)
#    endif
#    if BOOST_PP_LOCAL_C(180)
        BOOST_PP_LOCAL_MACRO(180)
#    endif
#    if BOOST_PP_LOCAL_C(181)
        BOOST_PP_LOCAL_MACRO(181)
#    endif
#    if BOOST_PP_LOCAL_C(182)
        BOOST_PP_LOCAL_MACRO(182)
#    endif
#    if BOOST_PP_LOCAL_C(183)
        BOOST_PP_LOCAL_MACRO(183)
#    endif
#    if BOOST_PP_LOCAL_C(184)
        BOOST_PP_LOCAL_MACRO(184)
#    endif
#    if BOOST_PP_LOCAL_C(185)
        BOOST_PP_LOCAL_MACRO(185)
#    endif
#    if BOOST_PP_LOCAL_C(186)
        BOOST_PP_LOCAL_MACRO(186)
#    endif
#    if BOOST_PP_LOCAL_C(187)
        BOOST_PP_LOCAL_MACRO(187)
#    endif
#    if BOOST_PP_LOCAL_C(188)
        BOOST_PP_LOCAL_MACRO(188)
#    endif
#    if BOOST_PP_LOCAL_C(189)
        BOOST_PP_LOCAL_MACRO(189)
#    endif
#    if BOOST_PP_LOCAL_C(190)
        BOOST_PP_LOCAL_MACRO(190)
#    endif
#    if BOOST_PP_LOCAL_C(191)
        BOOST_PP_LOCAL_MACRO(191)
#    endif
#    if BOOST_PP_LOCAL_C(192)
        BOOST_PP_LOCAL_MACRO(192)
#    endif
#    if BOOST_PP_LOCAL_C(193)
        BOOST_PP_LOCAL_MACRO(193)
#    endif
#    if BOOST_PP_LOCAL_C(194)
        BOOST_PP_LOCAL_MACRO(194)
#    endif
#    if BOOST_PP_LOCAL_C(195)
        BOOST_PP_LOCAL_MACRO(195)
#    endif
#    if BOOST_PP_LOCAL_C(196)
        BOOST_PP_LOCAL_MACRO(196)
#    endif
#    if BOOST_PP_LOCAL_C(197)
        BOOST_PP_LOCAL_MACRO(197)
#    endif
#    if BOOST_PP_LOCAL_C(198)
        BOOST_PP_LOCAL_MACRO(198)
#    endif
#    if BOOST_PP_LOCAL_C(199)
        BOOST_PP_LOCAL_MACRO(199)
#    endif
#    if BOOST_PP_LOCAL_C(200)
        BOOST_PP_LOCAL_MACRO(200)
#    endif
#    if BOOST_PP_LOCAL_C(201)
        BOOST_PP_LOCAL_MACRO(201)
#    endif
#    if BOOST_PP_LOCAL_C(202)
        BOOST_PP_LOCAL_MACRO(202)
#    endif
#    if BOOST_PP_LOCAL_C(203)
        BOOST_PP_LOCAL_MACRO(203)
#    endif
#    if BOOST_PP_LOCAL_C(204)
        BOOST_PP_LOCAL_MACRO(204)
#    endif
#    if BOOST_PP_LOCAL_C(205)
        BOOST_PP_LOCAL_MACRO(205)
#    endif
#    if BOOST_PP_LOCAL_C(206)
        BOOST_PP_LOCAL_MACRO(206)
#    endif
#    if BOOST_PP_LOCAL_C(207)
        BOOST_PP_LOCAL_MACRO(207)
#    endif
#    if BOOST_PP_LOCAL_C(208)
        BOOST_PP_LOCAL_MACRO(208)
#    endif
#    if BOOST_PP_LOCAL_C(209)
        BOOST_PP_LOCAL_MACRO(209)
#    endif
#    if BOOST_PP_LOCAL_C(210)
        BOOST_PP_LOCAL_MACRO(210)
#    endif
#    if BOOST_PP_LOCAL_C(211)
        BOOST_PP_LOCAL_MACRO(211)
#    endif
#    if BOOST_PP_LOCAL_C(212)
        BOOST_PP_LOCAL_MACRO(212)
#    endif
#    if BOOST_PP_LOCAL_C(213)
        BOOST_PP_LOCAL_MACRO(213)
#    endif
#    if BOOST_PP_LOCAL_C(214)
        BOOST_PP_LOCAL_MACRO(214)
#    endif
#    if BOOST_PP_LOCAL_C(215)
        BOOST_PP_LOCAL_MACRO(215)
#    endif
#    if BOOST_PP_LOCAL_C(216)
        BOOST_PP_LOCAL_MACRO(216)
#    endif
#    if BOOST_PP_LOCAL_C(217)
        BOOST_PP_LOCAL_MACRO(217)
#    endif
#    if BOOST_PP_LOCAL_C(218)
        BOOST_PP_LOCAL_MACRO(218)
#    endif
#    if BOOST_PP_LOCAL_C(219)
        BOOST_PP_LOCAL_MACRO(219)
#    endif
#    if BOOST_PP_LOCAL_C(220)
        BOOST_PP_LOCAL_MACRO(220)
#    endif
#    if BOOST_PP_LOCAL_C(221)
        BOOST_PP_LOCAL_MACRO(221)
#    endif
#    if BOOST_PP_LOCAL_C(222)
        BOOST_PP_LOCAL_MACRO(222)
#    endif
#    if BOOST_PP_LOCAL_C(223)
        BOOST_PP_LOCAL_MACRO(223)
#    endif
#    if BOOST_PP_LOCAL_C(224)
        BOOST_PP_LOCAL_MACRO(224)
#    endif
#    if BOOST_PP_LOCAL_C(225)
        BOOST_PP_LOCAL_MACRO(225)
#    endif
#    if BOOST_PP_LOCAL_C(226)
        BOOST_PP_LOCAL_MACRO(226)
#    endif
#    if BOOST_PP_LOCAL_C(227)
        BOOST_PP_LOCAL_MACRO(227)
#    endif
#    if BOOST_PP_LOCAL_C(228)
        BOOST_PP_LOCAL_MACRO(228)
#    endif
#    if BOOST_PP_LOCAL_C(229)
        BOOST_PP_LOCAL_MACRO(229)
#    endif
#    if BOOST_PP_LOCAL_C(230)
        BOOST_PP_LOCAL_MACRO(230)
#    endif
#    if BOOST_PP_LOCAL_C(231)
        BOOST_PP_LOCAL_MACRO(231)
#    endif
#    if BOOST_PP_LOCAL_C(232)
        BOOST_PP_LOCAL_MACRO(232)
#    endif
#    if BOOST_PP_LOCAL_C(233)
        BOOST_PP_LOCAL_MACRO(233)
#    endif
#    if BOOST_PP_LOCAL_C(234)
        BOOST_PP_LOCAL_MACRO(234)
#    endif
#    if BOOST_PP_LOCAL_C(235)
        BOOST_PP_LOCAL_MACRO(235)
#    endif
#    if BOOST_PP_LOCAL_C(236)
        BOOST_PP_LOCAL_MACRO(236)
#    endif

#    if BOOST_PP_LOCAL_C(237)
        BOOST_PP_LOCAL_MACRO(237)
#    endif
#    if BOOST_PP_LOCAL_C(238)
        BOOST_PP_LOCAL_MACRO(238)
#    endif
#    if BOOST_PP_LOCAL_C(239)
        BOOST_PP_LOCAL_MACRO(239)
#    endif
#    if BOOST_PP_LOCAL_C(240)
        BOOST_PP_LOCAL_MACRO(240)
#    endif
#    if BOOST_PP_LOCAL_C(241)
        BOOST_PP_LOCAL_MACRO(241)
#    endif
#    if BOOST_PP_LOCAL_C(242)
        BOOST_PP_LOCAL_MACRO(242)
#    endif
#    if BOOST_PP_LOCAL_C(243)
        BOOST_PP_LOCAL_MACRO(243)
#    endif
#    if BOOST_PP_LOCAL_C(244)
        BOOST_PP_LOCAL_MACRO(244)
#    endif
#    if BOOST_PP_LOCAL_C(245)
        BOOST_PP_LOCAL_MACRO(245)
#    endif
#    if BOOST_PP_LOCAL_C(246)
        BOOST_PP_LOCAL_MACRO(246)
#    endif
#    if BOOST_PP_LOCAL_C(247)
        BOOST_PP_LOCAL_MACRO(247)
#    endif
#    if BOOST_PP_LOCAL_C(248)
        BOOST_PP_LOCAL_MACRO(248)
#    endif
#    if BOOST_PP_LOCAL_C(249)
        BOOST_PP_LOCAL_MACRO(249)
#    endif
#    if BOOST_PP_LOCAL_C(250)
        BOOST_PP_LOCAL_MACRO(250)
#    endif
#    if BOOST_PP_LOCAL_C(251)
        BOOST_PP_LOCAL_MACRO(251)
#    endif
#    if BOOST_PP_LOCAL_C(252)
        BOOST_PP_LOCAL_MACRO(252)
#    endif
#    if BOOST_PP_LOCAL_C(253)
        BOOST_PP_LOCAL_MACRO(253)
#    endif
#    if BOOST_PP_LOCAL_C(254)
        BOOST_PP_LOCAL_MACRO(254)
#    endif
#    if BOOST_PP_LOCAL_C(255)
        BOOST_PP_LOCAL_MACRO(255)
#    endif
#    if BOOST_PP_LOCAL_C(256)
        BOOST_PP_LOCAL_MACRO(256)
#    endif
# endif
#
# undef BOOST_PP_LOCAL_LIMITS
#
# undef BOOST_PP_LOCAL_S
# undef BOOST_PP_LOCAL_F
#
# undef BOOST_PP_LOCAL_MACRO


code:
#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
#define BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// binary_wiarchive.hpp

// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to 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 updates, documentation, and revision history.

#include <boost/config.hpp>
#ifdef BOOST_NO_STD_WSTREAMBUF
#error "wide char i/o not supported on this platform"
#else

#include <istream> // wistream
#include <boost/archive/binary_iarchive_impl.hpp>
#include <boost/archive/detail/register_archive.hpp>

namespace boost {
namespace archive {

class binary_wiarchive :
    public binary_iarchive_impl<
        binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
    >
{
public:
    binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
        binary_iarchive_impl<
            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
        >(is, flags)
    {}
    binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
        binary_iarchive_impl<
            binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
        >(bsb, flags)
    {}
};

} // namespace archive
} // namespace boost

// required by export
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)

#endif // BOOST_NO_STD_WSTREAMBUF
#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP


code:
//  (C) Copyright Jeremy Siek 2004
//  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_QUEUE_HPP
#define BOOST_QUEUE_HPP

#include <deque>
#include <algorithm>

namespace boost {

template <class _Tp,
          class _Sequence = std::deque<_Tp> >
class queue;

template <class _Tp, class _Seq>
inline bool operator==(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);

template <class _Tp, class _Seq>
inline bool operator<(const queue<_Tp, _Seq>&, const queue<_Tp, _Seq>&);

template <class _Tp, class _Sequence>
class queue {

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
  template <class _Tp1, class _Seq1>
  friend bool operator== (const queue<_Tp1, _Seq1>&,
                          const queue<_Tp1, _Seq1>&);
  template <class _Tp1, class _Seq1>
  friend bool operator< (const queue<_Tp1, _Seq1>&,
                         const queue<_Tp1, _Seq1>&);
#endif
public:
  typedef typename _Sequence::value_type      value_type;
  typedef typename _Sequence::size_type       size_type;
  typedef          _Sequence                  container_type;

  typedef typename _Sequence::reference       reference;
  typedef typename _Sequence::const_reference const_reference;
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
protected:
#endif
  _Sequence c;
public:
  queue() : c() {}
  explicit queue(const _Sequence& __c) : c(__c) {}

  bool empty() const { return c.empty(); }
  size_type size() const { return c.size(); }
  reference front() { return c.front(); }
  const_reference front() const { return c.front(); }
  reference top() { return c.front(); }
  const_reference top() const { return c.front(); }
  reference back() { return c.back(); }
  const_reference back() const { return c.back(); }
  void push(const value_type& __x) { c.push_back(__x); }
  void pop() { c.pop_front(); }

  void swap(queue& other)
  {
    using std::swap;
    swap(c, other.c);
  }
};

template <class _Tp, class _Sequence>
bool
operator==(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return __x.c == __y.c;
}

template <class _Tp, class _Sequence>
bool
operator<(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return __x.c < __y.c;
}

template <class _Tp, class _Sequence>
bool
operator!=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return !(__x == __y);
}

template <class _Tp, class _Sequence>
bool
operator>(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return __y < __x;
}

template <class _Tp, class _Sequence>
bool
operator<=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return !(__y < __x);
}

template <class _Tp, class _Sequence>
bool
operator>=(const queue<_Tp, _Sequence>& __x, const queue<_Tp, _Sequence>& __y)
{
  return !(__x < __y);
}

template <class _Tp, class _Sequence>
inline void
swap(queue<_Tp, _Sequence>& __x, queue<_Tp, _Sequence>& __y)
{ __x.swap(__y); }

} /* namespace boost */

#endif /* BOOST_QUEUE_HPP */


code:
/*==============================================================================
    Copyright (c) 2005-2010 Joel de Guzman
    Copyright (c) 2010-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)
==============================================================================*/
#ifndef BOOST_PHOENIX_SCOPE_LOCAL_VARIABLE_HPP
#define BOOST_PHOENIX_SCOPE_LOCAL_VARIABLE_HPP

#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/core/call.hpp>
#include <boost/phoenix/core/expression.hpp>
#include <boost/phoenix/core/reference.hpp>
#include <boost/phoenix/core/value.hpp>
#include <boost/phoenix/scope/scoped_environment.hpp>
#include <boost/phoenix/scope/detail/local_variable.hpp>
#include <boost/phoenix/statement/sequence.hpp>

namespace boost { namespace phoenix
{
    namespace expression
    {
        template <typename Key>
        struct local_variable
            : expression::terminal<detail::local<Key> >
        {
            typedef typename expression::terminal<detail::local<Key> >::type type;

            static type make()
            {
                type const e = {};
                return e;
            }
        };
    }

    namespace rule
    {
        struct local_variable
            : expression::local_variable<proto::_>
        {};

        struct local_var_def
            : proto::assign<local_variable, meta_grammar>
        {};
    }

    namespace result_of
    {
        template <typename Key>
        struct is_nullary<custom_terminal<detail::local<Key> > >
            : mpl::false_
        {};
    }

    namespace detail
    {
        struct scope_is_nullary_actions
        {
            template <typename Rule, typename Dummy = void>
            struct when
                : boost::phoenix::is_nullary::when<Rule, Dummy>
            {};
        };

        template <typename Dummy>
        struct scope_is_nullary_actions::when<boost::phoenix::rule::custom_terminal, Dummy>
            : proto::or_<
                proto::when<boost::phoenix::rule::local_variable, mpl::true_()>
              , proto::otherwise<
                    is_nullary::when<boost::phoenix::rule::custom_terminal, Dummy>
                >
            >
        {};

        struct local_var_not_found
        {
        };
    }

    template<typename Key>
    struct is_custom_terminal<detail::local<Key> >
      : mpl::true_
    {};

  template <typename Key>
  struct custom_terminal<detail::local<Key> >
    {
        template <typename Sig>
        struct result;

        template <typename This, typename Local, typename Context>
        struct result<This(Local, Context)>
            : result<This(Local const &, Context)>
        {};

        template <typename This, typename Local, typename Context>
        struct result<This(Local &, Context)>
        {
            typedef
                typename remove_reference<
                    typename result_of::env<Context>::type
                >::type
                env_type;

                typedef typename detail::apply_local<detail::local<Key>, env_type>::type type;
        };

        template <typename Local, typename Context>
        typename result<custom_terminal(Local const &, Context const&)>::type
        operator()(Local, Context const & ctx)
        {
            typedef
                typename remove_reference<
                    typename result_of::env<Context>::type
                >::type
                env_type;

                typedef typename detail::apply_local<detail::local<Key>, env_type>::type return_type;

            static const int index_value = detail::get_index<typename env_type::map_type, detail::local<Key> >::value;

            typedef detail::eval_local<Key> eval_local;

            // Detect if the return_type is for a value.
            //typedef typename is_value<return_type>::type is_value_type;

            return eval_local::template get<return_type, index_value>(
                phoenix::env(ctx));
        }
    };

    namespace local_names
    {
        typedef expression::local_variable<struct _a_key>::type _a_type;
        typedef expression::local_variable<struct _b_key>::type _b_type;
        typedef expression::local_variable<struct _c_key>::type _c_type;
        typedef expression::local_variable<struct _d_key>::type _d_type;
        typedef expression::local_variable<struct _e_key>::type _e_type;
        typedef expression::local_variable<struct _f_key>::type _f_type;
        typedef expression::local_variable<struct _g_key>::type _g_type;
        typedef expression::local_variable<struct _h_key>::type _h_type;
        typedef expression::local_variable<struct _i_key>::type _i_type;
        typedef expression::local_variable<struct _j_key>::type _j_type;
        typedef expression::local_variable<struct _k_key>::type _k_type;
        typedef expression::local_variable<struct _l_key>::type _l_type;
        typedef expression::local_variable<struct _m_key>::type _m_type;
        typedef expression::local_variable<struct _n_key>::type _n_type;
        typedef expression::local_variable<struct _o_key>::type _o_type;
        typedef expression::local_variable<struct _p_key>::type _p_type;
        typedef expression::local_variable<struct _q_key>::type _q_type;
        typedef expression::local_variable<struct _r_key>::type _r_type;
        typedef expression::local_variable<struct _s_key>::type _s_type;
        typedef expression::local_variable<struct _t_key>::type _t_type;
        typedef expression::local_variable<struct _u_key>::type _u_type;
        typedef expression::local_variable<struct _v_key>::type _v_type;
        typedef expression::local_variable<struct _w_key>::type _w_type;
        typedef expression::local_variable<struct _x_key>::type _x_type;
        typedef expression::local_variable<struct _y_key>::type _y_type;
        typedef expression::local_variable<struct _z_key>::type _z_type;

#ifndef BOOST_PHOENIX_NO_PREDEFINED_TERMINALS
        BOOST_ATTRIBUTE_UNUSED _a_type const _a = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _b_type const _b = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _c_type const _c = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _d_type const _d = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _e_type const _e = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _f_type const _f = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _g_type const _g = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _h_type const _h = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _i_type const _i = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _j_type const _j = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _k_type const _k = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _l_type const _l = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _m_type const _m = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _n_type const _n = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _o_type const _o = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _p_type const _p = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _q_type const _q = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _r_type const _r = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _s_type const _s = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _t_type const _t = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _u_type const _u = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _v_type const _v = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _w_type const _w = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _x_type const _x = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _y_type const _y = {{{}}};
        BOOST_ATTRIBUTE_UNUSED _z_type const _z = {{{}}};
#endif
    }
}}

#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_CONTAINER_MAPPED_VIEW_HPP
#define BOOST_COMPUTE_CONTAINER_MAPPED_VIEW_HPP

#include <cstddef>
#include <exception>

#include <boost/config.hpp>
#include <boost/throw_exception.hpp>

#include <boost/compute/buffer.hpp>
#include <boost/compute/system.hpp>
#include <boost/compute/context.hpp>
#include <boost/compute/command_queue.hpp>
#include <boost/compute/iterator/buffer_iterator.hpp>

namespace boost {
namespace compute {

/// \class mapped_view
/// \brief A mapped view of host memory.
///
/// The mapped_view class simplifies mapping host-memory to a compute
/// device. This allows for host-allocated memory to be used with the
/// Boost.Compute algorithms.
///
/// The following example shows how to map a simple C-array containing
/// data on the host to the device and run the reduce() algorithm to
/// calculate the sum:
///
/// \snippet test/test_mapped_view.cpp reduce
///
/// \see buffer
template<class T>
class mapped_view
{
public:
    typedef T value_type;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef buffer_iterator<T> iterator;
    typedef buffer_iterator<T> const_iterator;

    /// Creates a null mapped_view object.
    mapped_view()
    {
        m_mapped_ptr = 0;
    }

    /// Creates a mapped_view for \p host_ptr with \p n elements. After
    /// constructing a mapped_view the data is available for use by a
    /// compute device. Use the \p unmap() method to make the updated data
    /// available to the host.
    mapped_view(T *host_ptr,
                size_type n,
                const context &context = system::default_context())
        : m_buffer(_make_mapped_buffer(host_ptr, n, context))
    {
        m_mapped_ptr = 0;
    }

    /// Creates a read-only mapped_view for \p host_ptr with \p n elements.
    /// After constructing a mapped_view the data is available for use by a
    /// compute device. Use the \p unmap() method to make the updated data
    /// available to the host.
    mapped_view(const T *host_ptr,
                size_type n,
                const context &context = system::default_context())
        : m_buffer(_make_mapped_buffer(host_ptr, n, context))
    {
        m_mapped_ptr = 0;
    }

    /// Creates a copy of \p other.
    mapped_view(const mapped_view<T> &other)
        : m_buffer(other.m_buffer)
    {
        m_mapped_ptr = 0;
    }

    /// Copies the mapped buffer from \p other.
    mapped_view<T>& operator=(const mapped_view<T> &other)
    {
        if(this != &other){
            m_buffer = other.m_buffer;
            m_mapped_ptr = 0;
        }

        return *this;
    }

    /// Destroys the mapped_view object.
    ~mapped_view()
    {
    }

    /// Returns an iterator to the first element in the mapped_view.
    iterator begin()
    {
        return ::boost::compute::make_buffer_iterator<T>(m_buffer, 0);
    }

    /// Returns a const_iterator to the first element in the mapped_view.
    const_iterator begin() const
    {
        return ::boost::compute::make_buffer_iterator<T>(m_buffer, 0);
    }

    /// Returns a const_iterator to the first element in the mapped_view.
    const_iterator cbegin() const
    {
        return begin();
    }

    /// Returns an iterator to one past the last element in the mapped_view.
    iterator end()
    {
        return ::boost::compute::make_buffer_iterator<T>(m_buffer, size());
    }

    /// Returns a const_iterator to one past the last element in the mapped_view.
    const_iterator end() const
    {
        return ::boost::compute::make_buffer_iterator<T>(m_buffer, size());
    }

    /// Returns a const_iterator to one past the last element in the mapped_view.
    const_iterator cend() const
    {
        return end();
    }

    /// Returns the number of elements in the mapped_view.
    size_type size() const
    {
        return m_buffer.size() / sizeof(T);
    }

    /// Returns the host data pointer.
    T* get_host_ptr()
    {
        return static_cast<T *>(m_buffer.get_info<void *>(CL_MEM_HOST_PTR));
    }

    /// Returns the host data pointer.
    const T* get_host_ptr() const
    {
        return static_cast<T *>(m_buffer.get_info<void *>(CL_MEM_HOST_PTR));
    }

    /// Resizes the mapped_view to \p size elements.
    void resize(size_type size)
    {
        T *old_ptr = get_host_ptr();

        m_buffer = _make_mapped_buffer(old_ptr, size, m_buffer.get_context());
    }

    /// Returns \c true if the mapped_view is empty.
    bool empty() const
    {
        return size() == 0;
    }

    /// Returns the mapped buffer.
    const buffer& get_buffer() const
    {
        return m_buffer;
    }

    /// Maps the buffer into the host address space.
    ///
    /// \see_opencl_ref{clEnqueueMapBuffer}
    void map(cl_map_flags flags, command_queue &queue)
    {
        BOOST_ASSERT(m_mapped_ptr == 0);

        m_mapped_ptr = queue.enqueue_map_buffer(
            m_buffer, flags, 0, m_buffer.size()
        );
    }

    /// Maps the buffer into the host address space for reading and writing.
    ///
    /// Equivalent to:
    /// \code
    /// map(CL_MAP_READ | CL_MAP_WRITE, queue);
    /// \endcode
    void map(command_queue &queue)
    {
        map(CL_MAP_READ | CL_MAP_WRITE, queue);
    }

    /// Unmaps the buffer from the host address space.
    ///
    /// \see_opencl_ref{clEnqueueUnmapMemObject}
    void unmap(command_queue &queue)
    {
        BOOST_ASSERT(m_mapped_ptr != 0);

        queue.enqueue_unmap_buffer(m_buffer, m_mapped_ptr);

        m_mapped_ptr = 0;
    }

private:
    /// \internal_
    static buffer _make_mapped_buffer(T *host_ptr,
                                      size_t n,
                                      const context &context)
    {
        return buffer(
            context,
            n * sizeof(T),
            buffer::read_write | buffer::use_host_ptr,
            host_ptr
        );
    }

    /// \internal_
    static buffer _make_mapped_buffer(const T *host_ptr,
                                      size_t n,
                                      const context &context)
    {
        return buffer(
            context,
            n * sizeof(T),
            buffer::read_only | buffer::use_host_ptr,
            const_cast<void *>(static_cast<const void *>(host_ptr))
        );
    }

private:
    buffer m_buffer;
    void *m_mapped_ptr;
};

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

#endif // BOOST_COMPUTE_CONTAINER_MAPPED_VIEW_HPP


code:
//
//  Copyright (c) 2000-2002
//  Joerg Walter, Mathias Koch
//
//  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)
//
//  The authors gratefully acknowledge the support of
//  GeNeSys mbH & Co. KG in producing this work.
//

#ifndef _BOOST_UBLAS_OPERATION_SPARSE_
#define _BOOST_UBLAS_OPERATION_SPARSE_

#include <boost/numeric/ublas/traits.hpp>

// These scaled additions were borrowed from MTL unashamedly.
// But Alexei Novakov had a lot of ideas to improve these. Thanks.

namespace boost { namespace numeric { namespace ublas {

    template<class M, class E1, class E2, class TRI>
    BOOST_UBLAS_INLINE
    M &
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2,
                 M &m, TRI,
                 row_major_tag) {
        typedef M matrix_type;
        typedef TRI triangular_restriction;
        typedef const E1 expression1_type;
        typedef const E2 expression2_type;
        typedef typename M::size_type size_type;
        typedef typename M::value_type value_type;

        // ISSUE why is there a dense vector here?
        vector<value_type> temporary (e2 ().size2 ());
        temporary.clear ();
        typename expression1_type::const_iterator1 it1 (e1 ().begin1 ());
        typename expression1_type::const_iterator1 it1_end (e1 ().end1 ());
        while (it1 != it1_end) {
            size_type jb (temporary.size ());
            size_type je (0);
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
            typename expression1_type::const_iterator2 it2 (it1.begin ());
            typename expression1_type::const_iterator2 it2_end (it1.end ());
#else
            typename expression1_type::const_iterator2 it2 (boost::numeric::ublas::begin (it1, iterator1_tag ()));
            typename expression1_type::const_iterator2 it2_end (boost::numeric::ublas::end (it1, iterator1_tag ()));
#endif
            while (it2 != it2_end) {
                // temporary.plus_assign (*it2 * row (e2 (), it2.index2 ()));
                matrix_row<expression2_type> mr (e2 (), it2.index2 ());
                typename matrix_row<expression2_type>::const_iterator itr (mr.begin ());
                typename matrix_row<expression2_type>::const_iterator itr_end (mr.end ());
                while (itr != itr_end) {
                    size_type j (itr.index ());
                    temporary (j) += *it2 * *itr;
                    jb = (std::min) (jb, j);
                    je = (std::max) (je, j);
                    ++ itr;
                }
                ++ it2;
            }
            for (size_type j = jb; j < je + 1; ++ j) {
                if (temporary (j) != value_type/*zero*/()) {
                    // FIXME we'll need to extend the container interface!
                    // m.push_back (it1.index1 (), j, temporary (j));
                    // FIXME What to do with adaptors?
                    // m.insert (it1.index1 (), j, temporary (j));
                    if (triangular_restriction::other (it1.index1 (), j))
                        m (it1.index1 (), j) = temporary (j);
                    temporary (j) = value_type/*zero*/();
                }
            }
            ++ it1;
        }
        return m;
    }

    template<class M, class E1, class E2, class TRI>
    BOOST_UBLAS_INLINE
    M &
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2,
                 M &m, TRI,
                 column_major_tag) {
        typedef M matrix_type;
        typedef TRI triangular_restriction;
        typedef const E1 expression1_type;
        typedef const E2 expression2_type;
        typedef typename M::size_type size_type;
        typedef typename M::value_type value_type;

        // ISSUE why is there a dense vector here?
        vector<value_type> temporary (e1 ().size1 ());
        temporary.clear ();
        typename expression2_type::const_iterator2 it2 (e2 ().begin2 ());
        typename expression2_type::const_iterator2 it2_end (e2 ().end2 ());
        while (it2 != it2_end) {
            size_type ib (temporary.size ());
            size_type ie (0);
#ifndef BOOST_UBLAS_NO_NESTED_CLASS_RELATION
            typename expression2_type::const_iterator1 it1 (it2.begin ());
            typename expression2_type::const_iterator1 it1_end (it2.end ());
#else
            typename expression2_type::const_iterator1 it1 (boost::numeric::ublas::begin (it2, iterator2_tag ()));
            typename expression2_type::const_iterator1 it1_end (boost::numeric::ublas::end (it2, iterator2_tag ()));
#endif
            while (it1 != it1_end) {
                // column (m, it2.index2 ()).plus_assign (*it1 * column (e1 (), it1.index1 ()));
                matrix_column<expression1_type> mc (e1 (), it1.index1 ());
                typename matrix_column<expression1_type>::const_iterator itc (mc.begin ());
                typename matrix_column<expression1_type>::const_iterator itc_end (mc.end ());
                while (itc != itc_end) {
                    size_type i (itc.index ());
                    temporary (i) += *it1 * *itc;
                    ib = (std::min) (ib, i);
                    ie = (std::max) (ie, i);
                    ++ itc;
                }
                ++ it1;
            }
            for (size_type i = ib; i < ie + 1; ++ i) {
                if (temporary (i) != value_type/*zero*/()) {
                    // FIXME we'll need to extend the container interface!
                    // m.push_back (i, it2.index2 (), temporary (i));
                    // FIXME What to do with adaptors?
                    // m.insert (i, it2.index2 (), temporary (i));
                    if (triangular_restriction::other (i, it2.index2 ()))
                        m (i, it2.index2 ()) = temporary (i);
                    temporary (i) = value_type/*zero*/();
                }
            }
            ++ it2;
        }
        return m;
    }

    // Dispatcher
    template<class M, class E1, class E2, class TRI>
    BOOST_UBLAS_INLINE
    M &
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2,
                 M &m, TRI, bool init = true) {
        typedef typename M::value_type value_type;
        typedef TRI triangular_restriction;
        typedef typename M::orientation_category orientation_category;

        if (init)
            m.assign (zero_matrix<value_type> (e1 ().size1 (), e2 ().size2 ()));
        return sparse_prod (e1, e2, m, triangular_restriction (), orientation_category ());
    }
    template<class M, class E1, class E2, class TRI>
    BOOST_UBLAS_INLINE
    M
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2,
                 TRI) {
        typedef M matrix_type;
        typedef TRI triangular_restriction;

        matrix_type m (e1 ().size1 (), e2 ().size2 ());
        // FIXME needed for c_matrix?!
        // return sparse_prod (e1, e2, m, triangular_restriction (), false);
        return sparse_prod (e1, e2, m, triangular_restriction (), true);
    }
    template<class M, class E1, class E2>
    BOOST_UBLAS_INLINE
    M &
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2,
                 M &m, bool init = true) {
        typedef typename M::value_type value_type;
        typedef typename M::orientation_category orientation_category;

        if (init)
            m.assign (zero_matrix<value_type> (e1 ().size1 (), e2 ().size2 ()));
        return sparse_prod (e1, e2, m, full (), orientation_category ());
    }
    template<class M, class E1, class E2>
    BOOST_UBLAS_INLINE
    M
    sparse_prod (const matrix_expression<E1> &e1,
                 const matrix_expression<E2> &e2) {
        typedef M matrix_type;

        matrix_type m (e1 ().size1 (), e2 ().size2 ());
        // FIXME needed for c_matrix?!
        // return sparse_prod (e1, e2, m, full (), false);
        return sparse_prod (e1, e2, m, full (), true);
    }

}}}

#endif


code:
For this step and the next, you may want to pretend you are K1JT
by entering that callsign temporarily as *My Call* on the
*Settings | General* tab.  Your results should then be identical to
those shown in the screen shot below.

.Open a Wave File:

- Select *File | Open* and select the file
+...\save\samples\JT9\130418_1742.wav+. When the file opens you should
see something similar to the following screen shot:

[[X12]]
image::main-ui.png[align="center",alt="Main UI and Wide Graph"]

.Decoding Overview

Decoding takes place at the end of a receive sequence and proceeds in
two steps.  The first decode is done at the selected Rx frequency,
indicated by the U-shaped green marker on the waterfall frequency
scale.  Results appear in both the left (*Band Activity*) and right
(*Rx Frequency*) text windows on the main screen. The program then
finds and decodes all signals in the selected mode over the displayed
frequency range. The red marker on the waterfall scale indicates your
Tx frequency.

Seven JT9 signals are present in the example file, all decodable.
When this file was recorded KF4RWA was finishing a QSO with K1JT.
Since the green marker was placed at his audio frequency, 1224 Hz, his
message `K1JT KF4RWA 73` is decoded first and appears in the *Rx
Frequency* window. The *Band Activity* window shows this message plus
all decodes at other frequencies.  By default lines containing `CQ`
are highlighted in green, and lines with *My Call* (in this case K1JT)
in red.

[[X13]]
.Decoding Controls

To gain some feeling for controls frequently used when making QSOs,
try clicking with the mouse on the decoded text lines and on the
waterfall spectral display. You should be able to confirm the
following behavior:

- Click or double-click on either of the decoded lines highlighted in
green. These actions produce the following results:

** Callsign and locator of a station calling CQ are copied to the *DX
Call* and *DX Grid* entry fields.

** Messages are generated for a standard minimal QSO.

** The *Tx even* box is checked or cleared appropriately, so that you
will transmit in the proper (odd or even) minutes.

** The Rx frequency marker is moved to the frequency of the CQing
station.

** The *Gen Msg* ("`generated message`") radio button at bottom right
of the main window is selected.

** *Double-click* does all of the above and also activates *Enable Tx*
so that a transmission will start automatically at the proper time.

** You can modify the double-click behavior by holding down the
*Shift* key to move only the Tx frequency or the *Ctrl* key to move
both Rx and Tx frequencies.

NOTE: You can prevent your Tx frequency from being changed by checking the
box *Hold Tx Freq*.

- Double-click on the decoded message `K1JT N5KDV EM41`, highlighted
in red.  Results will be similar to those in the previous step. The Tx
frequency (red marker) is not moved unless *Shift* or *Ctrl* is held
down.  Messages highlighted in red are usually in response to your own
CQ or from a tail-ender, and you probably want your Tx frequency to
stay where it was.

- Click somewhere on the waterfall to set Rx frequency (green marker
on waterfall scale).

- Shift-click on the waterfall to set Tx frequency (red marker).

- Ctrl-click on the waterfall to set both Rx and Tx frequencies.

- Double-click on a signal in the waterfall to set Rx frequency and
start a narrow-band decode there. Decoded text will appear in the
right window only.

- Ctrl-double-click on a signal to set both Rx and Tx frequencies and
decode at the new frequency.

- Click *Erase* to clear the right window.

- Double-click *Erase* to clear both text windows.


code:
/*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman

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

#include <boost/fusion/support/config.hpp>
#include <boost/fusion/support/detail/access.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/add_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/bool.hpp>

namespace boost { namespace fusion
{
    namespace detail
    {
        template <typename Cons>
        struct cons_deref
        {
            typedef typename Cons::car_type type;
        };

        template <typename Cons, int I>
        struct cons_advance
        {
            typedef typename
                cons_advance<Cons, I-1>::type::cdr_type
            type;
        };

        template <typename Cons>
        struct cons_advance<Cons, 0>
        {
            typedef Cons type;
        };

        template <typename Cons>
        struct cons_advance<Cons, 1>
        {
            typedef typename Cons::cdr_type type;
        };

        template <typename Cons>
        struct cons_advance<Cons, 2>
        {
#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
            typedef typename Cons::cdr_type::cdr_type type;
#else
            typedef typename Cons::cdr_type _a;
            typedef typename _a::cdr_type type;
#endif
        };

        template <typename Cons>
        struct cons_advance<Cons, 3>
        {
#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
            typedef typename Cons::cdr_type::cdr_type::cdr_type type;
#else
            typedef typename Cons::cdr_type _a;
            typedef typename _a::cdr_type _b;
            typedef typename _b::cdr_type type;
#endif
        };

        template <typename Cons>
        struct cons_advance<Cons, 4>
        {
#if BOOST_WORKAROUND(BOOST_MSVC, > 1400) // VC8 and above
            typedef typename Cons::cdr_type::cdr_type::cdr_type::cdr_type type;
#else
            typedef typename Cons::cdr_type _a;
            typedef typename _a::cdr_type _b;
            typedef typename _b::cdr_type _c;
            typedef typename _c::cdr_type type;
#endif
        };
    }

    struct cons_tag;

    namespace extension
    {
        template <typename Tag>
        struct at_impl;

        template <>
        struct at_impl<cons_tag>
        {
            template <typename Sequence, typename N>
            struct apply
            {
                typedef typename detail::cons_deref<
                    typename detail::cons_advance<Sequence, N::value>::type>::type
                element;

                typedef typename
                    mpl::if_<
                        is_const<Sequence>
                      , typename detail::cref_result<element>::type
                      , typename detail::ref_result<element>::type
                    >::type
                type;

                template <typename Cons, int N2>
                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
                call(Cons& s, mpl::int_<N2>)
                {
                    return call(s.cdr, mpl::int_<N2-1>());
                }

                template <typename Cons>
                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
                call(Cons& s, mpl::int_<0>)
                {
                    return s.car;
                }

                BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
                static type
                call(Sequence& s)
                {
                    return call(s, mpl::int_<N::value>());
                }
            };
        };
    }
}}

#endif


code:
#ifndef BOOST_MPL_BACK_INSERTER_HPP_INCLUDED
#define BOOST_MPL_BACK_INSERTER_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2003-2004
// Copyright David Abrahams 2003-2004
//
// 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/libs/mpl for documentation.

// $Id$
// $Date$
// $Revision$

#include <boost/mpl/push_back.hpp>
#include <boost/mpl/inserter.hpp>

namespace boost {
namespace mpl {

template<
      typename Sequence
    >
struct back_inserter
    : inserter< Sequence,push_back<> >
{
};

}}

#endif // BOOST_MPL_BACK_INSERTER_HPP_INCLUDED


code:
#ifndef BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED
#define BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED

// Copyright Aleksey Gurtovoy 2003-2004
// Copyright David Abrahams 2003-2004
//
// 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/libs/mpl for documentation.

// $Id$
// $Date$
// $Revision$

namespace boost { namespace mpl { namespace aux {

struct map_tag;

}}}

#endif // BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED