#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
namespace boost { namespace spirit
{
    struct nil_t {};
}}
namespace boost {
namespace mpl {
namespace aux {
template< typename F > struct template_arity;
}
}
}
namespace boost { namespace mpl {
template< bool C_ > struct bool_;
typedef bool_<true> true_;
typedef bool_<false> false_;
}}
namespace boost { namespace mpl {
template< bool C_ > struct bool_
{
    static const bool value = C_;
    typedef bool_ type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};
template< bool C_ >
bool const bool_<C_>::value;
}}
namespace boost {
template< typename T > struct is_integral : mpl::bool_< false > { };
template<> struct is_integral< unsigned char > : mpl::bool_< true > { }; template<> struct is_integral< unsigned char const > : mpl::bool_< true > { }; template<> struct is_integral< unsigned char volatile > : mpl::bool_< true > { }; template<> struct is_integral< unsigned char const volatile > : mpl::bool_< true > { };
template<> struct is_integral< unsigned short > : mpl::bool_< true > { }; template<> struct is_integral< unsigned short const > : mpl::bool_< true > { }; template<> struct is_integral< unsigned short volatile > : mpl::bool_< true > { }; template<> struct is_integral< unsigned short const volatile > : mpl::bool_< true > { };
template<> struct is_integral< unsigned int > : mpl::bool_< true > { }; template<> struct is_integral< unsigned int const > : mpl::bool_< true > { }; template<> struct is_integral< unsigned int volatile > : mpl::bool_< true > { }; template<> struct is_integral< unsigned int const volatile > : mpl::bool_< true > { };
template<> struct is_integral< unsigned long > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long const > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long volatile > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long const volatile > : mpl::bool_< true > { };
template<> struct is_integral< signed char > : mpl::bool_< true > { }; template<> struct is_integral< signed char const > : mpl::bool_< true > { }; template<> struct is_integral< signed char volatile > : mpl::bool_< true > { }; template<> struct is_integral< signed char const volatile > : mpl::bool_< true > { };
template<> struct is_integral< signed short > : mpl::bool_< true > { }; template<> struct is_integral< signed short const > : mpl::bool_< true > { }; template<> struct is_integral< signed short volatile > : mpl::bool_< true > { }; template<> struct is_integral< signed short const volatile > : mpl::bool_< true > { };
template<> struct is_integral< signed int > : mpl::bool_< true > { }; template<> struct is_integral< signed int const > : mpl::bool_< true > { }; template<> struct is_integral< signed int volatile > : mpl::bool_< true > { }; template<> struct is_integral< signed int const volatile > : mpl::bool_< true > { };
template<> struct is_integral< signed long > : mpl::bool_< true > { }; template<> struct is_integral< signed long const > : mpl::bool_< true > { }; template<> struct is_integral< signed long volatile > : mpl::bool_< true > { }; template<> struct is_integral< signed long const volatile > : mpl::bool_< true > { };
template<> struct is_integral< bool > : mpl::bool_< true > { }; template<> struct is_integral< bool const > : mpl::bool_< true > { }; template<> struct is_integral< bool volatile > : mpl::bool_< true > { }; template<> struct is_integral< bool const volatile > : mpl::bool_< true > { };
template<> struct is_integral< char > : mpl::bool_< true > { }; template<> struct is_integral< char const > : mpl::bool_< true > { }; template<> struct is_integral< char volatile > : mpl::bool_< true > { }; template<> struct is_integral< char const volatile > : mpl::bool_< true > { };
template<> struct is_integral< wchar_t > : mpl::bool_< true > { }; template<> struct is_integral< wchar_t const > : mpl::bool_< true > { }; template<> struct is_integral< wchar_t volatile > : mpl::bool_< true > { }; template<> struct is_integral< wchar_t const volatile > : mpl::bool_< true > { };
template<> struct is_integral< unsigned long long > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long long const > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long long volatile > : mpl::bool_< true > { }; template<> struct is_integral< unsigned long long const volatile > : mpl::bool_< true > { };
template<> struct is_integral< long long > : mpl::bool_< true > { }; template<> struct is_integral< long long const > : mpl::bool_< true > { }; template<> struct is_integral< long long volatile > : mpl::bool_< true > { }; template<> struct is_integral< long long const volatile > : mpl::bool_< true > { };
}
namespace boost {
template< typename T > struct is_float : mpl::bool_< false > { };
template<> struct is_float< float > : mpl::bool_< true > { }; template<> struct is_float< float const > : mpl::bool_< true > { }; template<> struct is_float< float volatile > : mpl::bool_< true > { }; template<> struct is_float< float const volatile > : mpl::bool_< true > { };
template<> struct is_float< double > : mpl::bool_< true > { }; template<> struct is_float< double const > : mpl::bool_< true > { }; template<> struct is_float< double volatile > : mpl::bool_< true > { }; template<> struct is_float< double const volatile > : mpl::bool_< true > { };
template<> struct is_float< long double > : mpl::bool_< true > { }; template<> struct is_float< long double const > : mpl::bool_< true > { }; template<> struct is_float< long double volatile > : mpl::bool_< true > { }; template<> struct is_float< long double const volatile > : mpl::bool_< true > { };
}
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
    static const bool value = true;
};
template <>
struct ice_or<false, false, false, false, false, false, false>
{
    static const bool value = false;
};
}
}
namespace boost {
namespace detail {
template< typename T >
struct is_arithmetic_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);
};
}
template< typename T > struct is_arithmetic : mpl::bool_< ::boost::detail::is_arithmetic_impl<T>::value > { };
}
namespace boost {
template< typename T > struct is_void : mpl::bool_< false > { };
template<> struct is_void< void > : mpl::bool_< true > { };
template<> struct is_void< void const > : mpl::bool_< true > { };
template<> struct is_void< void volatile > : mpl::bool_< true > { };
template<> struct is_void< void const volatile > : mpl::bool_< true > { };
}
namespace boost {
namespace detail {
template <typename T>
struct is_fundamental_impl
    : ::boost::type_traits::ice_or<
          ::boost::is_arithmetic<T>::value
        , ::boost::is_void<T>::value
        >
{
};
}
template< typename T > struct is_fundamental : mpl::bool_< ::boost::detail::is_fundamental_impl<T>::value > { };
}
namespace boost {
template< typename T > struct is_array : mpl::bool_< false > { };
template< typename T, std::size_t N > struct is_array< T[N] > : mpl::bool_< true > { };
template< typename T, std::size_t N > struct is_array< T const[N] > : mpl::bool_< true > { };
template< typename T, std::size_t N > struct is_array< T volatile[N] > : mpl::bool_< true > { };
template< typename T, std::size_t N > struct is_array< T const volatile[N] > : mpl::bool_< true > { };
}
namespace boost {
template< typename T > struct is_reference : mpl::bool_< false > { };
template< typename T > struct is_reference< T& > : mpl::bool_< true > { };
}
namespace boost {
namespace detail {
template <typename T>
struct add_reference_impl
{
    typedef T& type;
};
template< typename T > struct add_reference_impl<T&> { typedef T& type; };
template<> struct add_reference_impl<void> { typedef void type; };
template<> struct add_reference_impl<void const> { typedef void const type; };
template<> struct add_reference_impl<void volatile> { typedef void volatile type; };
template<> struct add_reference_impl<void const volatile> { typedef void const volatile type; };
}
template< typename T > struct add_reference { typedef typename detail::add_reference_impl<T>::type type; };
}
namespace boost {
namespace type_traits {
typedef char yes_type;
struct no_type
{
   char padding[8];
};
}
}
namespace boost {
namespace type_traits {
template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;
template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
    static const bool value = false;
};
template <>
struct ice_and<true, true, true, true, true, true, true>
{
    static const bool value = true;
};
}
}
namespace boost {
namespace type_traits {
template <bool b>
struct ice_not
{
    static const bool value = true;
};
template <>
struct ice_not<true>
{
    static const bool value = false;
};
}
}
namespace boost {
namespace type_traits {
template <int b1, int b2>
struct ice_eq
{
    static const bool value = (b1 == b2);
};
template <int b1, int b2>
struct ice_ne
{
    static const bool value = (b1 != b2);
};
template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;
}
}
namespace boost {
namespace detail {
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(T&);
};
template <typename T> struct checker
{
    static boost::type_traits::no_type _m_check(any_conversion ...);
    static boost::type_traits::yes_type _m_check(T, int);
};
template <typename From, typename To>
struct is_convertible_basic_impl
{
    static From _m_from;
    static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) )
        == sizeof(::boost::type_traits::yes_type);
};
template <typename From, typename To>
struct is_convertible_impl
{
    typedef typename add_reference<From>::type ref_type;
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value);
};
    template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (false); };
}
template< typename From, typename To > struct is_convertible : mpl::bool_< (::boost::detail::is_convertible_impl<From,To>::value) > { };
template<> struct is_convertible< float,char > : mpl::bool_< true > { }; template<> struct is_convertible< float,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< float,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< float,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< float,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< float,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< float,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< float,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< float,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< float,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< float,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< float const,char > : mpl::bool_< true > { }; template<> struct is_convertible< float const,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< float const,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< float const,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< float const,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< float const,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< float const,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< float const,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< float const,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< float const,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< float const,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< float volatile,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< float const volatile,unsigned long long > : mpl::bool_< true > { };
template<> struct is_convertible< double,char > : mpl::bool_< true > { }; template<> struct is_convertible< double,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< double,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< double,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< double,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< double,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< double,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< double,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< double,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< double,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< double,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< double const,char > : mpl::bool_< true > { }; template<> struct is_convertible< double const,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< double const,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< double const,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< double const,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< double const,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< double const,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< double const,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< double const,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< double const,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< double const,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< double volatile,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< double const volatile,unsigned long long > : mpl::bool_< true > { };
template<> struct is_convertible< long double,char > : mpl::bool_< true > { }; template<> struct is_convertible< long double,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< long double,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< long double,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< long double,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< long double,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< long double,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< long double,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< long double,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< long double,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double volatile,unsigned long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,signed char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,unsigned char > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,signed short > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,unsigned short > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,signed int > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,unsigned int > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,signed long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,unsigned long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,signed long long > : mpl::bool_< true > { }; template<> struct is_convertible< long double const volatile,unsigned long long > : mpl::bool_< true > { };
}
namespace boost {
namespace type_traits {
struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};
}}
namespace boost {
namespace type_traits {
template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};
template <class R>
struct is_function_ptr_helper<R (*)()> { static const bool value = true; };
template <class R,class T0>
struct is_function_ptr_helper<R (*)(T0)> { static const bool value = true; };
template <class R,class T0,class T1>
struct is_function_ptr_helper<R (*)(T0,T1)> { static const bool value = true; };
template <class R,class T0,class T1,class T2>
struct is_function_ptr_helper<R (*)(T0,T1,T2)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)> { static const bool value = true; };
template <class R,class T0,class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10,class T11,class T12,class T13,class T14,class T15,class T16,class T17,class T18,class T19,class T20,class T21,class T22,class T23,class T24>
struct is_function_ptr_helper<R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)> { static const bool value = true; };
}
}
namespace boost {
namespace detail {
template<bool is_ref = true>
struct is_function_chooser
    : ::boost::type_traits::false_result
{
};
template <>
struct is_function_chooser<false>
{
    template< typename T > struct result_
        : ::boost::type_traits::is_function_ptr_helper<T*>
    {
    };
};
template <typename T>
struct is_function_impl
    : is_function_chooser< ::boost::is_reference<T>::value >
        ::template result_<T>
{
};
}
template< typename T > struct is_function : mpl::bool_< ::boost::detail::is_function_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T> struct cv_traits_imp {};
template <typename T>
struct cv_traits_imp<T*>
{
    static const bool is_const = false;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const T*>
{
    static const bool is_const = true;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<volatile T*>
{
    static const bool is_const = false;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};
template <typename T>
struct cv_traits_imp<const volatile T*>
{
    static const bool is_const = true;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};
}
}
namespace boost {
template< typename T > struct remove_cv { typedef typename detail::cv_traits_imp<T*>::unqualified_type type; };
template< typename T > struct remove_cv<T&> { typedef T& type; };
template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
}
namespace boost {
namespace detail {
template <typename T> struct is_union_impl
{
   static const bool value = false;
};
}
template< typename T > struct is_union : mpl::bool_< ::boost::detail::is_union_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <class U> ::boost::type_traits::yes_type is_class_tester(void(U::*)(void));
template <class U> ::boost::type_traits::no_type is_class_tester(...);
template <typename T>
struct is_class_impl
{
    static const bool value = (::boost::type_traits::ice_and< sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type), ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value >::value);
};
}
template< typename T > struct is_class : mpl::bool_< ::boost::detail::is_class_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct is_class_or_union
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_class<T>::value , ::boost::is_union<T>::value >::value);
};
struct int_convertible
{
    int_convertible(int);
};
template <bool is_typename_arithmetic_or_reference = true>
struct is_enum_helper
{
    template <typename T> struct type
    {
        static const bool value = false;
    };
};
template <>
struct is_enum_helper<false>
{
    template <typename T> struct type
        : ::boost::is_convertible<T,::boost::detail::int_convertible>
    {
    };
};
template <typename T> struct is_enum_impl
{
   typedef ::boost::add_reference<T> ar_t;
   typedef typename ar_t::type r_type;
   static const bool selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value , ::boost::is_reference<T>::value , ::boost::is_function<T>::value , is_class_or_union<T>::value >::value);
    typedef ::boost::detail::is_enum_helper<selector> se_t;
    typedef typename se_t::template type<r_type> helper;
    static const bool value = helper::value;
};
template<> struct is_enum_impl< void > { static const bool value = (false); };
template<> struct is_enum_impl< void const > { static const bool value = (false); };
template<> struct is_enum_impl< void volatile > { static const bool value = (false); };
template<> struct is_enum_impl< void const volatile > { static const bool value = (false); };
}
template< typename T > struct is_enum : mpl::bool_< ::boost::detail::is_enum_impl<T>::value > { };
}
namespace boost {
namespace type_traits {
template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };
template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };
template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };
template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };
}
}
namespace boost {
template< typename T > struct is_member_function_pointer : mpl::bool_< ::boost::type_traits::is_mem_fun_pointer_impl<T>::value > { };
}
namespace boost {
template< typename T > struct is_member_pointer : mpl::bool_< ::boost::is_member_function_pointer<T>::value > { };
template< typename T, typename U > struct is_member_pointer< U T::* > : mpl::bool_< true > { };
}
namespace boost {
namespace detail {
template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};
template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* const> { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* volatile> { static const bool value = true; };
template< typename T > struct is_pointer_helper<T* const volatile> { static const bool value = true; };
template< typename T >
struct is_pointer_impl
{
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<T>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
};
}
template< typename T > struct is_pointer : mpl::bool_< ::boost::detail::is_pointer_impl<T>::value > { };
}
namespace boost{
namespace detail{
template <typename T, bool small_>
struct ct_imp2
{
   typedef const T& param_type;
};
template <typename T>
struct ct_imp2<T, true>
{
   typedef const T param_type;
};
template <typename T, bool isp, bool b1>
struct ct_imp
{
   typedef const T& param_type;
};
template <typename T, bool isp>
struct ct_imp<T, isp, true>
{
   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
};
template <typename T, bool b1>
struct ct_imp<T, true, b1>
{
   typedef T const param_type;
};
}
template <typename T>
struct call_traits
{
public:
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef typename detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value
   >::param_type param_type;
};
template <typename T>
struct call_traits<T&>
{
   typedef T& value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef T& param_type;
};
template <typename T, std::size_t N>
struct call_traits<T [N]>
{
private:
   typedef T array_type[N];
public:
   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};
template <typename T, std::size_t N>
struct call_traits<const T [N]>
{
private:
   typedef const T array_type[N];
public:
   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};
}
#include <assert.h>
namespace boost {
  template <class T>
  struct type {};
}
namespace boost { namespace mpl {
template< std::size_t N > struct size_t;
}}
namespace boost { namespace mpl {
template< std::size_t N >
struct size_t
{
    static const std::size_t value = N;
    typedef size_t type;
    typedef std::size_t value_type;
    typedef mpl::size_t< static_cast<std::size_t>((value + 1)) > next;
    typedef mpl::size_t< static_cast<std::size_t>((value - 1)) > prior;
    operator std::size_t() const { return static_cast<std::size_t>(this->value); }
};
template< std::size_t N >
std::size_t const mpl::size_t< N >::value;
}}
namespace boost {
template <typename T> struct alignment_of;
namespace detail {
template <typename T>
struct alignment_of_hack
{
    char c;
    T t;
    alignment_of_hack();
};
template <unsigned A, unsigned S>
struct alignment_logic
{
    static const std::size_t value = A < S ? A : S;
};
template< typename T >
struct alignment_of_impl
{
    static const std::size_t value = (::boost::detail::alignment_logic< sizeof(detail::alignment_of_hack<T>) - sizeof(T), sizeof(T) >::value);
};
}
template< typename T > struct alignment_of : mpl::size_t< ::boost::detail::alignment_of_impl<T>::value > { };
template <typename T>
struct alignment_of<T&>
    : alignment_of<T*>
{
};
template<> struct alignment_of<void> : mpl::size_t< 0 > { };
template<> struct alignment_of<void const> : mpl::size_t< 0 > { };
template<> struct alignment_of<void volatile> : mpl::size_t< 0 > { };
template<> struct alignment_of<void const volatile> : mpl::size_t< 0 > { };
}
namespace boost {
namespace mpl {
struct void_;
}
}
namespace boost {
namespace mpl {
struct void_ { typedef void_ type; };
template< typename T >
struct is_void_
    : false_
{
};
template<>
struct is_void_<void_>
    : true_
{
};
}
}
namespace boost {
namespace mpl {
template<
      typename T
    , typename Tag
    , typename Arity
    >
struct lambda;
}
}
namespace boost { namespace mpl {
template< int N > struct int_;
}}
namespace boost {
namespace mpl {
template< int N > struct arg;
}
}
namespace boost {
namespace mpl {
namespace algo_ {
template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};
template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};
template<
      typename C = void_
    , typename T1 = void_
    , typename T2 = void_
    >
struct if_
{
 private:
    typedef if_c<
          static_cast<bool>(C::value)
        , T1
        , T2
        > almost_type_;
 public:
    typedef typename almost_type_::type type;
   
};
} using namespace algo_;
namespace algo_ { template<> struct if_< void_,void_,void_ > { template< typename T1,typename T2,typename T3 , typename T4 =void_ ,typename T5 =void_ > struct apply : if_< T1,T2,T3 > { }; }; } using namespace algo_; template<> struct lambda< algo_:: if_< void_,void_,void_ > , void_ , int_<-1> > { typedef algo_:: if_< void_,void_,void_ > type; }; namespace aux { template< typename T1,typename T2,typename T3 > struct template_arity< algo_:: if_< T1,T2,T3 > > { static const int value = 3; }; template<> struct template_arity< algo_:: if_< void_,void_,void_ > > { static const int value = -1; }; }
template <class T1, class T2, class T3, class T4> struct bind3;
template <template <class T1, class T2, class T3> class F, class tag> struct quote3;
namespace aux
{
  template <
      typename T
    , typename U1,typename U2,typename U3,typename U4,typename U5
  > struct resolve_bind_arg;
  template<
        typename T
      , typename Arg
      >
  struct replace_unnamed_arg;
}
template<
      typename T1, typename T2, typename T3
    >
struct bind3<quote3<if_, void_>, T1, T2, T3>
{
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
     private:
        typedef quote3<if_, void_> a0;
        typedef mpl::arg< 1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next_arg n2;
        typedef typename aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 >::type t1;
        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next_arg n3;
        typedef typename aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > f2;
        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next_arg n4;
        typedef typename aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > f3;
        typedef typename if_<t1,f2,f3>::type f_;
     public:
        typedef typename f_::type type;
    };
};
}
}
namespace boost {
namespace detail {
template <typename T>
struct is_scalar_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value);
};
template <> struct is_scalar_impl<void>{ static const bool value = false; };
template <> struct is_scalar_impl<void const>{ static const bool value = false; };
template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };
}
template< typename T > struct is_scalar : mpl::bool_< ::boost::detail::is_scalar_impl<T>::value > { };
}
namespace boost {
template< typename T > struct is_POD;
namespace detail {
template <typename T> struct is_pod_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, false >::value);
};
template <typename T, std::size_t sz>
struct is_pod_impl<T[sz]>
    : is_pod_impl<T>
{
};
template<> struct is_pod_impl< void > { static const bool value = (true); };
template<> struct is_pod_impl< void const > { static const bool value = (true); };
template<> struct is_pod_impl< void volatile > { static const bool value = (true); };
template<> struct is_pod_impl< void const volatile > { static const bool value = (true); };
}
template< typename T > struct is_POD : mpl::bool_< ::boost::detail::is_pod_impl<T>::value > { };
template< typename T > struct is_pod : mpl::bool_< ::boost::detail::is_pod_impl<T>::value > { };
}
namespace boost{
template <bool x> struct STATIC_ASSERTION_FAILURE;
template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
template<int x> struct static_assert_test{};
}
namespace boost {
namespace detail {
class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();
template <bool found, std::size_t target, class TestType>
struct lower_alignment_helper
{
    typedef char type;
    enum { value = true };
};
template <std::size_t target, class TestType>
struct lower_alignment_helper<false,target,TestType>
{
    enum { value = (alignment_of<TestType>::value == target) };
    typedef typename mpl::if_c<value, TestType, char>::type type;
};
template <typename T>
struct has_one_T
{
  T data;
};
template <std::size_t target>
union lower_alignment
{
    enum { found0 = false };
    typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,float >::type t4; enum { found5 = lower_alignment_helper<found4,target,float >::value }; typename lower_alignment_helper< found5,target,double >::type t5; enum { found6 = lower_alignment_helper<found5,target,double >::value }; typename lower_alignment_helper< found6,target,long double >::type t6; enum { found7 = lower_alignment_helper<found6,target,long double >::value }; typename lower_alignment_helper< found7,target,void* >::type t7; enum { found8 = lower_alignment_helper<found7,target,void* >::value }; typename lower_alignment_helper< found8,target,function_ptr >::type t8; enum { found9 = lower_alignment_helper<found8,target,function_ptr >::value }; typename lower_alignment_helper< found9,target,member_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,member_ptr >::value }; typename lower_alignment_helper< found10,target,member_function_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_function_ptr >::value }; typename lower_alignment_helper< found11,target,boost::detail::has_one_T<char> >::type t11; enum { found12 = lower_alignment_helper<found11,target,boost::detail::has_one_T<char> >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T<short> >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T<short> >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T<int> >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T<int> >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T<long> >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T<long> >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T<float> >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T<float> >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T<double> >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T<double> >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T<long double> >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T<long double> >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T<void*> >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T<void*> >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T<function_ptr> >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T<function_ptr> >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T<member_ptr> >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T<member_ptr> >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T<member_function_ptr> >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T<member_function_ptr> >::value };
};
union max_align
{
    char t0; short t1; int t2; long t3; float t4; double t5; long double t6; void* t7; function_ptr t8; member_ptr t9; member_function_ptr t10; boost::detail::has_one_T<char> t11; boost::detail::has_one_T<short> t12; boost::detail::has_one_T<int> t13; boost::detail::has_one_T<long> t14; boost::detail::has_one_T<float> t15; boost::detail::has_one_T<double> t16; boost::detail::has_one_T<long double> t17; boost::detail::has_one_T<void*> t18; boost::detail::has_one_T<function_ptr> t19; boost::detail::has_one_T<member_ptr> t20; boost::detail::has_one_T<member_function_ptr> t21;
};
template<int TAlign, int Align>
struct is_aligned
{
    static const bool value = (TAlign >= Align) & (TAlign % Align == 0);
};
}
template<std::size_t Align>
struct is_pod< ::boost::detail::lower_alignment<Align> >
{
        static const std::size_t value = true;
};
template <int Align>
class type_with_alignment
{
    typedef detail::lower_alignment<Align> t1;
    typedef typename mpl::if_c<
          ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
        , t1
        , detail::max_align
        >::type align_t;
    static const std::size_t found = alignment_of<align_t>::value;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( found >= Align ) >)> boost_static_assert_typedef_197;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( found % Align == 0 ) >)> boost_static_assert_typedef_198;
 public:
    typedef align_t type;
};
namespace align {
struct __attribute__((__aligned__(2))) a2 {};
struct __attribute__((__aligned__(4))) a4 {};
struct __attribute__((__aligned__(8))) a8 {};
struct __attribute__((__aligned__(16))) a16 {};
struct __attribute__((__aligned__(32))) a32 {};
}
template<> class type_with_alignment<1> { public: typedef char type; };
template<> class type_with_alignment<2> { public: typedef align::a2 type; };
template<> class type_with_alignment<4> { public: typedef align::a4 type; };
template<> class type_with_alignment<8> { public: typedef align::a8 type; };
template<> class type_with_alignment<16> { public: typedef align::a16 type; };
template<> class type_with_alignment<32> { public: typedef align::a32 type; };
namespace detail {
template<> struct is_pod_impl< ::boost::align::a2 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a4 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a8 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a16 > { static const bool value = (true); };
template<> struct is_pod_impl< ::boost::align::a32 > { static const bool value = (true); };
}
}
namespace boost {
template< typename T > struct remove_reference { typedef T type; };
template< typename T > struct remove_reference<T&> { typedef T type; };
}
namespace boost { namespace mpl { namespace aux {
template< typename T >
struct nested_type_wknd
    : T::type
{
};
}}}
namespace boost {
namespace mpl {
namespace aux {
template< long C_ >
struct not_impl
    : bool_<!C_>
{
};
}
template<
      typename T = void_
    >
struct not_
    : aux::not_impl<
          ::boost::mpl::aux::nested_type_wknd<T>::value
        >
{
   
};
template<> struct not_< void_ > { template< typename T1 , typename T2 =void_ ,typename T3 =void_ ,typename T4 =void_ ,typename T5 =void_ > struct apply : not_< T1 > { }; }; template<> struct lambda< not_< void_ > , void_ , int_<-1> > { typedef not_< void_ > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > { static const int value = 1; }; template<> struct template_arity< not_< void_ > > { static const int value = -1; }; }
}
}
namespace boost {
template< typename T > struct is_volatile : mpl::bool_< ::boost::detail::cv_traits_imp<T*>::is_volatile > { };
template< typename T > struct is_volatile< T& > : mpl::bool_< false > { };
}
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_copy_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, false >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);
};
}
template< typename T > struct has_trivial_copy : mpl::bool_< ::boost::detail::has_trivial_copy_impl<T>::value > { };
}
namespace boost {
template< typename T > struct has_nothrow_copy : mpl::bool_< ::boost::has_trivial_copy<T>::value > { };
}
namespace boost {
namespace detail {
template <typename RefT>
class reference_content
{
private:
    RefT content_;
public:
    ~reference_content()
    {
    }
    reference_content(RefT r)
        : content_( r )
    {
    }
    reference_content(const reference_content& operand)
        : content_( operand.content_ )
    {
    }
private:
    reference_content& operator=(const reference_content&);
public:
    RefT get() const
    {
        return content_;
    }
};
template <typename T = mpl::void_> struct make_reference_content;
template <typename T>
struct make_reference_content
{
    typedef T type;
};
template <typename T>
struct make_reference_content< T& >
{
    typedef reference_content<T&> type;
};
template <>
struct make_reference_content< mpl::void_ >
{
    template <typename T>
    struct apply
        : make_reference_content<T>
    {
    };
    typedef mpl::void_ type;
};
}
template <typename T>
struct has_nothrow_copy<
      ::boost::detail::reference_content< T& >
    >
    : mpl::true_
{
};
}
namespace boost {
namespace detail {
struct none_helper{};
typedef int none_helper::*none_t ;
}
}
#include <functional>
namespace boost {
template<class OptionalPointee>
inline
bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
{
  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
}
template<class OptionalPointee>
struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
{
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return equal_pointees(x,y) ; }
} ;
template<class OptionalPointee>
inline
bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
{
  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
}
template<class OptionalPointee>
struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
{
  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return less_pointees(x,y) ; }
} ;
}
namespace boost {
class InPlaceFactoryBase ;
class TypedInPlaceFactoryBase ;
namespace optional_detail {
template <class T>
class aligned_storage
{
    union dummy_u
    {
        char data[ sizeof(T) ];
        typename type_with_alignment<
          ::boost::alignment_of<T>::value >::type aligner_;
    } dummy_ ;
  public:
    void const* address() const { return &dummy_.data[0]; }
    void * address() { return &dummy_.data[0]; }
} ;
template<class T>
struct types_when_isnt_ref
{
  typedef T const& reference_const_type ;
  typedef T & reference_type ;
  typedef T const* pointer_const_type ;
  typedef T * pointer_type ;
  typedef T const& argument_type ;
} ;
template<class T>
struct types_when_is_ref
{
  typedef typename remove_reference<T>::type raw_type ;
  typedef raw_type& reference_const_type ;
  typedef raw_type& reference_type ;
  typedef raw_type* pointer_const_type ;
  typedef raw_type* pointer_type ;
  typedef raw_type& argument_type ;
} ;
struct optional_tag {} ;
template<class T>
class optional_base : public optional_tag
{
  private :
    typedef typename detail::make_reference_content<T>::type internal_type ;
    typedef aligned_storage<internal_type> storage_type ;
    typedef types_when_isnt_ref<T> types_when_not_ref ;
    typedef types_when_is_ref<T> types_when_ref ;
    typedef optional_base<T> this_type ;
  protected :
    typedef T value_type ;
    typedef mpl::true_ is_reference_tag ;
    typedef mpl::false_ is_not_reference_tag ;
    typedef typename is_reference<T>::type is_reference_predicate ;
    typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
    typedef bool (this_type::*unspecified_bool_type)() const;
    typedef typename types::reference_type reference_type ;
    typedef typename types::reference_const_type reference_const_type ;
    typedef typename types::pointer_type pointer_type ;
    typedef typename types::pointer_const_type pointer_const_type ;
    typedef typename types::argument_type argument_type ;
    optional_base()
      :
      m_initialized(false) {}
    optional_base ( detail::none_t const& )
      :
      m_initialized(false) {}
    optional_base ( argument_type val )
      :
      m_initialized(false)
    {
      construct(val);
    }
    optional_base ( optional_base const& rhs )
      :
      m_initialized(false)
    {
      if ( rhs.is_initialized() )
        construct(rhs.get_impl());
    }
    template<class Expr>
    explicit optional_base ( Expr const& expr, Expr const* tag )
      :
      m_initialized(false)
    {
      construct(expr,tag);
    }
    ~optional_base() { destroy() ; }
    void assign ( optional_base const& rhs )
      {
        destroy();
        if ( rhs.is_initialized() )
          construct(rhs.get_impl());
      }
    void assign ( argument_type val )
      {
        destroy();
        construct(val);
      }
    void assign ( detail::none_t const& ) { destroy(); }
    template<class Expr>
    void assign_expr ( Expr const& expr, Expr const* tag )
      {
        destroy();
        construct(expr,tag);
      }
  public :
    void reset() { destroy(); }
    void reset ( argument_type val ) { assign(val); }
    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
    pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }
    bool is_initialized() const { return m_initialized ; }
  protected :
    void construct ( argument_type val )
     {
       new (m_storage.address()) internal_type(val) ;
       m_initialized = true ;
     }
    template<class Expr>
    void construct ( Expr const& factory, InPlaceFactoryBase const* )
     {
       typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::mpl::not_<is_reference_predicate>::value ) >)> boost_static_assert_typedef_268 ;
       factory.template apply<value_type>(m_storage.address()) ;
       m_initialized = true ;
     }
    template<class Expr>
    void construct ( Expr const& factory, TypedInPlaceFactoryBase const* )
     {
       typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::mpl::not_<is_reference_predicate>::value ) >)> boost_static_assert_typedef_277 ;
       factory.apply(m_storage.address()) ;
       m_initialized = true ;
     }
    template<class Expr>
    void construct ( Expr const& expr, void const* )
     {
       new (m_storage.address()) internal_type(expr) ;
       m_initialized = true ;
     }
    void destroy()
      {
        if ( m_initialized )
          destroy_impl(is_reference_predicate()) ;
      }
    unspecified_bool_type safe_bool() const { return m_initialized ? &this_type::is_initialized : 0 ; }
    reference_const_type get_impl() const { return dereference(get_object(), is_reference_predicate() ) ; }
    reference_type get_impl() { return dereference(get_object(), is_reference_predicate() ) ; }
    pointer_const_type get_ptr_impl() const { return cast_ptr(get_object(), is_reference_predicate() ) ; }
    pointer_type get_ptr_impl() { return cast_ptr(get_object(), is_reference_predicate() ) ; }
  private :
    internal_type const* get_object() const { return static_cast<internal_type const*>(m_storage.address()); }
    internal_type * get_object() { return static_cast<internal_type *> (m_storage.address()); }
    reference_const_type dereference( internal_type const* p, is_not_reference_tag ) const { return *p ; }
    reference_type dereference( internal_type* p, is_not_reference_tag ) { return *p ; }
    reference_const_type dereference( internal_type const* p, is_reference_tag ) const { return p->get() ; }
    reference_type dereference( internal_type* p, is_reference_tag ) { return p->get() ; }
    void destroy_impl ( is_not_reference_tag ) { get_impl().~T() ; m_initialized = false ; }
    void destroy_impl ( is_reference_tag ) { m_initialized = false ; }
    pointer_const_type cast_ptr( internal_type const* p, is_not_reference_tag ) const { return p ; }
    pointer_type cast_ptr( internal_type * p, is_not_reference_tag ) { return p ; }
    bool m_initialized ;
    storage_type m_storage ;
} ;
}
template<class T>
class optional : public optional_detail::optional_base<T>
{
    typedef optional_detail::optional_base<T> base ;
    typedef typename base::unspecified_bool_type unspecified_bool_type ;
  public :
    typedef optional<T> this_type ;
    typedef typename base::value_type value_type ;
    typedef typename base::reference_type reference_type ;
    typedef typename base::reference_const_type reference_const_type ;
    typedef typename base::pointer_type pointer_type ;
    typedef typename base::pointer_const_type pointer_const_type ;
    typedef typename base::argument_type argument_type ;
    optional() : base() {}
    optional( detail::none_t const& none_ ) : base(none_) {}
    optional ( argument_type val ) : base(val) {}
    template<class U>
    explicit optional ( optional<U> const& rhs )
      :
      base()
    {
      if ( rhs.is_initialized() )
        this->construct(rhs.get());
    }
    template<class Expr>
    explicit optional ( Expr const& expr ) : base(expr,&expr) {}
    optional ( optional const& rhs ) : base(rhs) {}
    ~optional() {}
    template<class Expr>
    optional& operator= ( Expr expr )
      {
        this->assign_expr(expr,&expr);
        return *this ;
      }
    template<class U>
    optional& operator= ( optional<U> const& rhs )
      {
        this->destroy();
        if ( rhs.is_initialized() )
        {
          this->assign(rhs.get());
        }
        return *this ;
      }
    optional& operator= ( optional const& rhs )
      {
        this->assign( rhs ) ;
        return *this ;
      }
    optional& operator= ( argument_type val )
      {
        this->assign( val ) ;
        return *this ;
      }
    optional& operator= ( detail::none_t const& none_ )
      {
        this->assign( none_ ) ;
        return *this ;
      }
    reference_const_type get() const { ((void)0) ; return this->get_impl(); }
    reference_type get() { ((void)0) ; return this->get_impl(); }
    pointer_const_type operator->() const { ((void)0) ; return this->get_ptr_impl() ; }
    pointer_type operator->() { ((void)0) ; return this->get_ptr_impl() ; }
    reference_const_type operator *() const { return this->get() ; }
    reference_type operator *() { return this->get() ; }
    operator unspecified_bool_type() const { return this->safe_bool() ; }
       bool operator!() const { return !this->is_initialized() ; }
} ;
template<class T>
inline
typename optional<T>::reference_const_type
get ( optional<T> const& opt )
{
  return opt.get() ;
}
template<class T>
inline
typename optional<T>::reference_type
get ( optional<T>& opt )
{
  return opt.get() ;
}
template<class T>
inline
typename optional<T>::pointer_const_type
get ( optional<T> const* opt )
{
  return opt->get_ptr() ;
}
template<class T>
inline
typename optional<T>::pointer_type
get ( optional<T>* opt )
{
  return opt->get_ptr() ;
}
template<class T>
inline
typename optional<T>::pointer_const_type
get_pointer ( optional<T> const& opt )
{
  return opt.get_ptr() ;
}
template<class T>
inline
typename optional<T>::pointer_type
get_pointer ( optional<T>& opt )
{
  return opt.get_ptr() ;
}
template<class T>
inline
bool operator == ( optional<T> const& x, optional<T> const& y )
{ return equal_pointees(x,y); }
template<class T>
inline
bool operator < ( optional<T> const& x, optional<T> const& y )
{ return less_pointees(x,y); }
template<class T>
inline
bool operator != ( optional<T> const& x, optional<T> const& y )
{ return !( x == y ) ; }
template<class T>
inline
bool operator > ( optional<T> const& x, optional<T> const& y )
{ return y < x ; }
template<class T>
inline
bool operator <= ( optional<T> const& x, optional<T> const& y )
{ return !( y < x ) ; }
template<class T>
inline
bool operator >= ( optional<T> const& x, optional<T> const& y )
{ return !( x < y ) ; }
template<class T>
inline
bool operator == ( optional<T> const& x, detail::none_t const& )
{ return equal_pointees(x, optional<T>() ); }
template<class T>
inline
bool operator < ( optional<T> const& x, detail::none_t const& )
{ return less_pointees(x,optional<T>() ); }
template<class T>
inline
bool operator != ( optional<T> const& x, detail::none_t const& y )
{ return !( x == y ) ; }
template<class T>
inline
bool operator > ( optional<T> const& x, detail::none_t const& y )
{ return y < x ; }
template<class T>
inline
bool operator <= ( optional<T> const& x, detail::none_t const& y )
{ return !( y < x ) ; }
template<class T>
inline
bool operator >= ( optional<T> const& x, detail::none_t const& y )
{ return !( x < y ) ; }
template<class T>
inline
bool operator == ( detail::none_t const& x, optional<T> const& y )
{ return equal_pointees(optional<T>() ,y); }
template<class T>
inline
bool operator < ( detail::none_t const& x, optional<T> const& y )
{ return less_pointees(optional<T>() ,y); }
template<class T>
inline
bool operator != ( detail::none_t const& x, optional<T> const& y )
{ return !( x == y ) ; }
template<class T>
inline
bool operator > ( detail::none_t const& x, optional<T> const& y )
{ return y < x ; }
template<class T>
inline
bool operator <= ( detail::none_t const& x, optional<T> const& y )
{ return !( y < x ) ; }
template<class T>
inline
bool operator >= ( detail::none_t const& x, optional<T> const& y )
{ return !( x < y ) ; }
namespace optional_detail {
template<class T>
inline
void optional_swap ( optional<T>& x, optional<T>& y )
{
  if ( !x && !!y )
  {
    x.reset(*y);
    y.reset();
  }
  else if ( !!x && !y )
  {
    y.reset(*x);
    x.reset();
  }
  else if ( !!x && !!y )
  {
    using std::swap ;
    swap(*x,*y);
  }
}
}
template<class T> inline void swap ( optional<T>& x, optional<T>& y )
{
  optional_detail::optional_swap(x,y);
}
}
namespace boost
{
template<class E> void throw_exception(E const & e)
{
    throw e;
}
}
namespace boost { namespace spirit
{
    namespace impl
    {
        template <typename T>
        struct no_base {};
        template <typename T>
        struct safe_bool_impl
        {
            typedef T* TP;
            TP stub;
            typedef TP safe_bool_impl::*type;
        };
    }
    template <typename DerivedT, typename BaseT = impl::no_base<DerivedT> >
    struct safe_bool : BaseT
    {
    private:
        typedef impl::safe_bool_impl<DerivedT> impl_t;
        typedef typename impl_t::type bool_type;
    public:
        operator bool_type() const
        {
            return static_cast<const DerivedT*>(this)->operator_bool() ?
                &impl_t::stub : 0;
        }
        operator bool_type()
        {
            return static_cast<DerivedT*>(this)->operator_bool() ?
                &impl_t::stub : 0;
        }
    };
}}
namespace boost { namespace spirit { namespace impl
{
    template <typename T>
    struct match_attr_traits
    {
        typedef typename
            boost::optional<T>::reference_const_type
        const_reference;
        static void
        convert(boost::optional<T>& dest, const_reference src)
        { dest.reset(src); }
        static void
        convert(boost::optional<T>& dest, ... )
        { dest.reset(); }
        template <typename OtherMatchT>
        static void
        copy(boost::optional<T>& dest, OtherMatchT const& src)
        {
            if (src.has_valid_attribute())
                convert(dest, src.value());
        }
        template <typename OtherMatchT>
        static void
        assign(boost::optional<T>& dest, OtherMatchT const& src)
        {
            if (src.has_valid_attribute())
                convert(dest, src.value());
            else
                dest.reset();
        }
        template <typename ValueT>
        static void
        set_value(boost::optional<T>& dest, ValueT const& val, mpl::false_)
        {
            dest.reset(val);
        }
        template <typename ValueT>
        static void
        set_value(boost::optional<T>& dest, ValueT const& val, mpl::true_)
        {
            dest.get() = val;
        }
    };
}}}
namespace boost {
template< typename T > struct add_const { typedef T const type; };
template< typename T > struct add_const<T&> { typedef T& type; };
}
namespace boost { namespace spirit
{
    template <typename T = nil_t>
    class match : public safe_bool<match<T> >
    {
    public:
        typedef typename boost::optional<T> optional_type;
        typedef typename optional_type::argument_type ctor_param_t;
        typedef typename optional_type::reference_const_type return_t;
        typedef T attr_t;
                                match();
        explicit match(std::size_t length);
                                match(std::size_t length, ctor_param_t val);
        bool operator!() const;
        std::ptrdiff_t length() const;
        bool has_valid_attribute() const;
        return_t value() const;
        void swap(match& other);
        template <typename T2>
        match(match<T2> const& other)
        : len(other.length()), val()
        {
            impl::match_attr_traits<T>::copy(val, other);
        }
        template <typename T2>
        match&
        operator=(match<T2> const& other)
        {
            impl::match_attr_traits<T>::assign(val, other);
            len = other.length();
            return *this;
        }
        template <typename MatchT>
        void
        concat(MatchT const& other)
        {
            ;
            len += other.length();
        }
        template <typename ValueT>
        void
        value(ValueT const& val_)
        {
            impl::match_attr_traits<T>::set_value(val, val_, is_reference<T>());
        }
        bool operator_bool() const
        {
            return len >= 0;
        }
    private:
        std::ptrdiff_t len;
        optional_type val;
    };
    template <>
    class match<nil_t> : public safe_bool<match<nil_t> >
    {
    public:
        typedef nil_t attr_t;
        typedef nil_t return_t;
                                match();
        explicit match(std::size_t length);
                                match(std::size_t length, nil_t);
        bool operator!() const;
        bool has_valid_attribute() const;
        std::ptrdiff_t length() const;
        nil_t value() const;
        void value(nil_t);
        void swap(match& other);
        template <typename T>
        match(match<T> const& other)
        : len(other.length()) {}
        template <typename T>
        match<>&
        operator=(match<T> const& other)
        {
            len = other.length();
            return *this;
        }
        template <typename T>
        void
        concat(match<T> const& other)
        {
            ;
            len += other.length();
        }
        bool operator_bool() const
        {
            return len >= 0;
        }
    private:
        std::ptrdiff_t len;
    };
}}
namespace boost { namespace spirit
{
    template <typename T>
    inline match<T>::match()
    : len(-1), val() {}
    template <typename T>
    inline match<T>::match(std::size_t length)
    : len(length), val() {}
    template <typename T>
    inline match<T>::match(std::size_t length, ctor_param_t val_)
    : len(length), val(val_) {}
    template <typename T>
    inline bool
    match<T>::operator!() const
    {
        return len < 0;
    }
    template <typename T>
    inline std::ptrdiff_t
    match<T>::length() const
    {
        return len;
    }
    template <typename T>
    inline bool
    match<T>::has_valid_attribute() const
    {
        return val.is_initialized();
    }
    template <typename T>
    inline typename match<T>::return_t
    match<T>::value() const
    {
        ;
        return *val;
    }
    template <typename T>
    inline void
    match<T>::swap(match& other)
    {
        std::swap(len, other.len);
        std::swap(val, other.val);
    }
    inline match<nil_t>::match()
    : len(-1) {}
    inline match<nil_t>::match(std::size_t length)
    : len(length) {}
    inline match<nil_t>::match(std::size_t length, nil_t)
    : len(length) {}
    inline bool
    match<nil_t>::operator!() const
    {
        return len < 0;
    }
    inline bool
    match<nil_t>::has_valid_attribute() const
    {
        return false;
    }
    inline std::ptrdiff_t
    match<nil_t>::length() const
    {
        return len;
    }
    inline nil_t
    match<nil_t>::value() const
    {
        return nil_t();
    }
    inline void
    match<nil_t>::value(nil_t) {}
    inline void
    match<nil_t>::swap(match& other)
    {
        std::swap(len, other.len);
    }
}}
#include <iterator>
namespace boost { namespace spirit {
    class parser_id
    {
    public:
                    parser_id() : p(0) {}
        explicit parser_id(void const* prule) : p(prule) {}
                    parser_id(std::size_t l_) : l(l_) {}
        bool operator==(parser_id const& x) const { return p == x.p; }
        bool operator!=(parser_id const& x) const { return !(*this == x); }
        bool operator<(parser_id const& x) const { return p < x.p; }
        std::size_t to_long() const { return l; }
    private:
        union
        {
            void const* p;
            std::size_t l;
        };
    };
    struct parser_tag_base {};
    struct parser_address_tag : parser_tag_base
    {
        parser_id id() const
        { return parser_id(reinterpret_cast<std::size_t>(this)); }
    };
    template <int N>
    struct parser_tag : parser_tag_base
    {
        static parser_id id()
        { return parser_id(std::size_t(N)); }
    };
    class dynamic_parser_tag : public parser_tag_base
    {
    public:
        dynamic_parser_tag()
        : tag(std::size_t(0)) {}
        parser_id
        id() const
        {
            return
                tag.to_long()
                ? tag
                : parser_id(reinterpret_cast<std::size_t>(this));
        }
        void set_id(parser_id id) { tag = id; }
    private:
        parser_id tag;
    };
}}
namespace boost { namespace detail {
template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;
}}
namespace boost { namespace spirit
{
    struct iteration_policy
    {
        template <typename ScannerT>
        void
        advance(ScannerT const& scan) const
        {
            ++scan.first;
        }
        template <typename ScannerT>
        bool at_end(ScannerT const& scan) const
        {
            return scan.first == scan.last;
        }
        template <typename T>
        T filter(T ch) const
        {
            return ch;
        }
        template <typename ScannerT>
        typename ScannerT::ref_t
        get(ScannerT const& scan) const
        {
            return *scan.first;
        }
    };
    struct match_policy
    {
        template <typename T>
        struct result { typedef match<T> type; };
        const match<nil_t>
        no_match() const
        {
            return match<nil_t>();
        }
        const match<nil_t>
        empty_match() const
        {
            return match<nil_t>(0, nil_t());
        }
        template <typename AttrT, typename IteratorT>
        match<AttrT>
        create_match(
            std::size_t length,
            AttrT const& val,
            IteratorT const& ,
            IteratorT const& ) const
        {
            return match<AttrT>(length, val);
        }
        template <typename MatchT, typename IteratorT>
        void group_match(
            MatchT& ,
            parser_id const& ,
            IteratorT const& ,
            IteratorT const& ) const {}
        template <typename Match1T, typename Match2T>
        void concat_match(Match1T& l, Match2T const& r) const
        {
            l.concat(r);
        }
    };
    template <typename MatchPolicyT, typename T>
    struct match_result
    {
        typedef typename MatchPolicyT::template result<T>::type type;
    };
    template <typename AttrT>
    struct attributed_action_policy
    {
        template <typename ActorT, typename IteratorT>
        static void
        call(
            ActorT const& actor,
            AttrT& val,
            IteratorT const&,
            IteratorT const&)
        {
            actor(val);
        }
    };
    template <>
    struct attributed_action_policy<nil_t>
    {
        template <typename ActorT, typename IteratorT>
        static void
        call(
            ActorT const& actor,
            nil_t,
            IteratorT const& first,
            IteratorT const& last)
        {
            actor(first, last);
        }
    };
    struct action_policy
    {
        template <typename ActorT, typename AttrT, typename IteratorT>
        void
        do_action(
            ActorT const& actor,
            AttrT& val,
            IteratorT const& first,
            IteratorT const& last) const
        {
            attributed_action_policy<AttrT>::call(actor, val, first, last);
        }
    };
    template <
        typename IterationPolicyT = iteration_policy,
        typename MatchPolicyT = match_policy,
        typename ActionPolicyT = action_policy>
    struct scanner_policies :
        public IterationPolicyT,
        public MatchPolicyT,
        public ActionPolicyT
    {
        typedef IterationPolicyT iteration_policy_t;
        typedef MatchPolicyT match_policy_t;
        typedef ActionPolicyT action_policy_t;
        scanner_policies(
            IterationPolicyT const& i_policy = IterationPolicyT(),
            MatchPolicyT const& m_policy = MatchPolicyT(),
            ActionPolicyT const& a_policy = ActionPolicyT())
        : IterationPolicyT(i_policy)
        , MatchPolicyT(m_policy)
        , ActionPolicyT(a_policy) {}
        template <typename ScannerPoliciesT>
        scanner_policies(ScannerPoliciesT const& policies)
        : IterationPolicyT(policies)
        , MatchPolicyT(policies)
        , ActionPolicyT(policies) {}
    };
    struct scanner_base {};
    template <
        typename IteratorT = char const*,
        typename PoliciesT = scanner_policies<> >
    class scanner : public PoliciesT, public scanner_base
    {
    public:
        typedef IteratorT iterator_t;
        typedef PoliciesT policies_t;
        typedef typename boost::detail::
            iterator_traits<IteratorT>::value_type value_t;
        typedef typename boost::detail::
            iterator_traits<IteratorT>::reference ref_t;
        typedef typename boost::
            call_traits<IteratorT>::param_type iter_param_t;
        scanner(
            IteratorT& first_,
            iter_param_t last_,
            PoliciesT const& policies = PoliciesT())
        : PoliciesT(policies), first(first_), last(last_)
        {
            at_end();
        }
        scanner(scanner const& other)
        : PoliciesT(other), first(other.first), last(other.last) {}
        scanner(scanner const& other, IteratorT& first_)
        : PoliciesT(other), first(first_), last(other.last) {}
        bool
        at_end() const
        {
            typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
            return iteration_policy_t::at_end(*this);
        }
        value_t
        operator*() const
        {
            typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
            return iteration_policy_t::filter(iteration_policy_t::get(*this));
        }
        scanner const&
        operator++() const
        {
            typedef typename PoliciesT::iteration_policy_t iteration_policy_t;
            iteration_policy_t::advance(*this);
            return *this;
        }
        template <typename PoliciesT2>
        struct rebind_policies
        {
            typedef scanner<IteratorT, PoliciesT2> type;
        };
        template <typename PoliciesT2>
        scanner<IteratorT, PoliciesT2>
        change_policies(PoliciesT2 const& policies) const
        {
            return scanner<IteratorT, PoliciesT2>(first, last, policies);
        }
        template <typename IteratorT2>
        struct rebind_iterator
        {
            typedef scanner<IteratorT2, PoliciesT> type;
        };
        template <typename IteratorT2>
        scanner<IteratorT2, PoliciesT>
        change_iterator(IteratorT2 const& first_, IteratorT2 const &last_) const
        {
            return scanner<IteratorT2, PoliciesT>(first_, last_, *this);
        }
        IteratorT& first;
        IteratorT const last;
    private:
        scanner&
        operator=(scanner const& other);
    };
    template <typename ScannerT, typename PoliciesT>
    struct rebind_scanner_policies
    {
        typedef typename ScannerT::template
            rebind_policies<PoliciesT>::type type;
    };
    template <typename ScannerT, typename IteratorT>
    struct rebind_scanner_iterator
    {
        typedef typename ScannerT::template
            rebind_iterator<IteratorT>::type type;
    };
}}
namespace boost { namespace spirit
{
    template <typename ParserT, typename ActionT>
    class action;
    struct plain_parser_category {};
    struct binary_parser_category : plain_parser_category {};
    struct unary_parser_category : plain_parser_category {};
    struct action_parser_category : unary_parser_category {};
    template <typename ParserT, typename ScannerT>
    struct parser_result
    {
        typedef typename ParserT::template result<ScannerT>::type type;
    };
    template <typename DerivedT>
    struct parser
    {
        typedef DerivedT embed_t;
        typedef DerivedT derived_t;
        typedef plain_parser_category parser_category_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, nil_t>::type type;
        };
        DerivedT& derived()
        {
            return *static_cast<DerivedT*>(this);
        }
        DerivedT const& derived() const
        {
            return *static_cast<DerivedT const*>(this);
        }
        template <typename ActionT>
        action<DerivedT, ActionT>
        operator[](ActionT const& actor) const
        {
            return action<DerivedT, ActionT>(derived(), actor);
        }
    };
    template <typename IteratorT = char const*>
    struct parse_info
    {
        IteratorT stop;
        bool hit;
        bool full;
        std::size_t length;
        parse_info(
            IteratorT const& stop_ = IteratorT(),
            bool hit_ = false,
            bool full_ = false,
            std::size_t length_ = 0)
        : stop(stop_)
        , hit(hit_)
        , full(full_)
        , length(length_) {}
        template <typename ParseInfoT>
        parse_info(ParseInfoT const& pi)
        : stop(pi.stop)
        , hit(pi.hit)
        , full(pi.full)
        , length(pi.length) {}
    };
    template <typename IteratorT, typename DerivedT>
    parse_info<IteratorT>
    parse(
        IteratorT const& first,
        IteratorT const& last,
        parser<DerivedT> const& p);
    template <typename CharT, typename DerivedT>
    parse_info<CharT const*>
    parse(
        CharT const* str,
        parser<DerivedT> const& p);
}}
namespace boost { namespace spirit
{
    template <typename IteratorT, typename DerivedT>
    inline parse_info<IteratorT>
    parse(
        IteratorT const& first_
      , IteratorT const& last
      , parser<DerivedT> const& p)
    {
        IteratorT first = first_;
        scanner<IteratorT, scanner_policies<> > scan(first, last);
        match<nil_t> hit = p.derived().parse(scan);
        return parse_info<IteratorT>(
            first, hit, hit && (first == last), hit.length());
    }
    template <typename CharT, typename DerivedT>
    inline parse_info<CharT const*>
    parse(CharT const* str, parser<DerivedT> const& p)
    {
        CharT const* last = str;
        while (*last)
            last++;
        return parse(str, last, p);
    }
}}
namespace boost {
template <typename T> T*
addressof(T& v)
{
  return reinterpret_cast<T*>(
       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}
}
namespace boost
{
template<class T> class reference_wrapper
{
public:
    typedef T type;
    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
    operator T& () const { return *t_; }
    T& get() const { return *t_; }
    T* get_pointer() const { return t_; }
private:
    T* t_;
};
template<class T> inline reference_wrapper<T> const ref(T & t)
{
    return reference_wrapper<T>(t);
}
template<class T> inline reference_wrapper<T const> const cref(T const & t)
{
    return reference_wrapper<T const>(t);
}
template<typename T>
class is_reference_wrapper
    : public mpl::false_
{
};
template<typename T>
class is_reference_wrapper<reference_wrapper<T> >
    : public mpl::true_
{
};
template<typename T>
class unwrap_reference
{
 public:
    typedef T type;
};
template<typename T>
class unwrap_reference<reference_wrapper<T> >
{
 public:
    typedef T type;
};
}
namespace boost { namespace spirit {
    template <typename DrivedT> struct char_parser;
    namespace impl
    {
        template <typename IteratorT>
        inline IteratorT
        get_last(IteratorT first)
        {
            while (*first)
                first++;
            return first;
        }
        template<
            typename RT,
            typename IteratorT,
            typename ScannerT>
        inline RT
        string_parser_parse(
            IteratorT str_first,
            IteratorT str_last,
            ScannerT& scan)
        {
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t saved = scan.first;
            std::size_t slen = str_last - str_first;
            while (str_first != str_last)
            {
                if (scan.at_end() || (*str_first != *scan))
                    return scan.no_match();
                ++str_first;
                ++scan;
            }
            return scan.create_match(slen, nil_t(), saved, scan.first);
        }
        template <typename CharT>
        inline typename
        std::char_traits<CharT>::int_type
        to_int_type(CharT c)
        {
            return std
                ::char_traits<CharT>::to_int_type(c);
        }
        template <typename CharT>
        inline CharT
        to_char_type(typename
            std::char_traits<CharT>::int_type c)
        {
            return std
                ::char_traits<CharT>::to_char_type(c);
        }
        inline bool
        isalnum_(char c)
        {
            using namespace std;
            return isalnum(to_int_type(c));
        }
        inline bool
        isalpha_(char c)
        {
            using namespace std;
            return isalpha(to_int_type(c));
        }
        inline bool
        iscntrl_(char c)
        {
            using namespace std;
            return iscntrl(to_int_type(c));
        }
        inline bool
        isdigit_(char c)
        {
            using namespace std;
            return isdigit(to_int_type(c));
        }
        inline bool
        isgraph_(char c)
        {
            using namespace std;
            return isgraph(to_int_type(c));
        }
        inline bool
        islower_(char c)
        {
            using namespace std;
            return islower(to_int_type(c));
        }
        inline bool
        isprint_(char c)
        {
            using namespace std;
            return isprint(to_int_type(c));
        }
        inline bool
        ispunct_(char c)
        {
            using namespace std;
            return ispunct(to_int_type(c));
        }
        inline bool
        isspace_(char c)
        {
            using namespace std;
            return isspace(to_int_type(c));
        }
        inline bool
        isupper_(char c)
        {
            using namespace std;
            return isupper(to_int_type(c)); }
        inline bool
        isxdigit_(char c)
        {
            using namespace std;
            return isxdigit(to_int_type(c));
        }
        inline bool
        isblank_(char c)
        {
            return (c == ' ' || c == '\t');
        }
        inline char
        tolower_(char c)
        {
            using namespace std;
            return to_char_type<char>(tolower(to_int_type(c)));
        }
        inline char
        toupper_(char c)
        {
            using namespace std;
            return to_char_type<char>(toupper(to_int_type(c)));
        }
}}}
namespace boost { namespace spirit {
    template <typename BaseT>
    struct no_skipper_iteration_policy;
    template <typename BaseT = iteration_policy>
    struct skipper_iteration_policy : public BaseT
    {
        typedef BaseT base_t;
        skipper_iteration_policy()
        : BaseT() {}
        template <typename PolicyT>
        skipper_iteration_policy(PolicyT const& other)
        : BaseT(other) {}
        template <typename ScannerT>
        void
        advance(ScannerT const& scan) const
        {
            BaseT::advance(scan);
            scan.skip(scan);
        }
        template <typename ScannerT>
        bool
        at_end(ScannerT const& scan) const
        {
            scan.skip(scan);
            return BaseT::at_end(scan);
        }
        template <typename ScannerT>
        void
        skip(ScannerT const& scan) const
        {
            while (!BaseT::at_end(scan) && impl::isspace_(BaseT::get(scan)))
                BaseT::advance(scan);
        }
    };
    namespace impl
    {
        template <typename ST, typename ScannerT, typename BaseT>
        void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            skipper_iteration_policy<BaseT> const&);
        template <typename ST, typename ScannerT, typename BaseT>
        void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            no_skipper_iteration_policy<BaseT> const&);
        template <typename ST, typename ScannerT>
        void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            iteration_policy const&);
    }
    template <typename ParserT, typename BaseT = iteration_policy>
    class skip_parser_iteration_policy : public skipper_iteration_policy<BaseT>
    {
    public:
        typedef skipper_iteration_policy<BaseT> base_t;
        skip_parser_iteration_policy(
            ParserT const& skip_parser,
            base_t const& base = base_t())
        : base_t(base), subject(skip_parser) {}
        template <typename PolicyT>
        skip_parser_iteration_policy(PolicyT const& other)
        : base_t(other), subject(other.skipper()) {}
        template <typename ScannerT>
        void
        skip(ScannerT const& scan) const
        {
            impl::skipper_skip(subject, scan, scan);
        }
        ParserT const&
        skipper() const
        {
            return subject;
        }
    private:
        ParserT const& subject;
    };
    template <typename IteratorT, typename ParserT, typename SkipT>
    parse_info<IteratorT>
    parse(
        IteratorT const& first,
        IteratorT const& last,
        parser<ParserT> const& p,
        parser<SkipT> const& skip);
    template <typename CharT, typename ParserT, typename SkipT>
    parse_info<CharT const*>
    parse(
        CharT const* str,
        parser<ParserT> const& p,
        parser<SkipT> const& skip);
    typedef skipper_iteration_policy<> iter_policy_t;
    typedef scanner_policies<iter_policy_t> scanner_policies_t;
    typedef scanner<char const*, scanner_policies_t> phrase_scanner_t;
    typedef scanner<wchar_t const*, scanner_policies_t> wide_phrase_scanner_t;
}}
namespace boost { namespace spirit {
    struct space_parser;
    template <typename BaseT>
    struct no_skipper_iteration_policy;
    namespace impl
    {
        template <typename ST, typename ScannerT, typename BaseT>
        inline void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            skipper_iteration_policy<BaseT> const&)
        {
            typedef scanner_policies<
                no_skipper_iteration_policy<
                    typename ScannerT::iteration_policy_t>,
                typename ScannerT::match_policy_t,
                typename ScannerT::action_policy_t
            > policies_t;
            scanner<typename ScannerT::iterator_t, policies_t>
                scan2(scan.first, scan.last, policies_t(scan));
            typedef typename ScannerT::iterator_t iterator_t;
            for (;;)
            {
                iterator_t save = scan.first;
                if (!s.parse(scan2))
                {
                    scan.first = save;
                    break;
                }
            }
        }
        template <typename ST, typename ScannerT, typename BaseT>
        inline void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            no_skipper_iteration_policy<BaseT> const&)
        {
            for (;;)
            {
                typedef typename ScannerT::iterator_t iterator_t;
                iterator_t save = scan.first;
                if (!s.parse(scan))
                {
                    scan.first = save;
                    break;
                }
            }
        }
        template <typename ST, typename ScannerT>
        inline void
        skipper_skip(
            ST const& s,
            ScannerT const& scan,
            iteration_policy const&)
        {
            for (;;)
            {
                typedef typename ScannerT::iterator_t iterator_t;
                iterator_t save = scan.first;
                if (!s.parse(scan))
                {
                    scan.first = save;
                    break;
                }
            }
        }
        template <typename SkipT>
        struct phrase_parser
        {
            template <typename IteratorT, typename ParserT>
            static parse_info<IteratorT>
            parse(
                IteratorT const& first_,
                IteratorT const& last,
                ParserT const& p,
                SkipT const& skip)
            {
                typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
                typedef scanner_policies<iter_policy_t> scanner_policies_t;
                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
                iter_policy_t iter_policy(skip);
                scanner_policies_t policies(iter_policy);
                IteratorT first = first_;
                scanner_t scan(first, last, policies);
                match<nil_t> hit = p.parse(scan);
                scan.skip(scan);
                return parse_info<IteratorT>(
                    first, hit, hit && (first == last),
                    hit.length());
            }
        };
        template <>
        struct phrase_parser<space_parser>
        {
            template <typename IteratorT, typename ParserT>
            static parse_info<IteratorT>
            parse(
                IteratorT const& first_,
                IteratorT const& last,
                ParserT const& p,
                space_parser const&)
            {
                typedef skipper_iteration_policy<> iter_policy_t;
                typedef scanner_policies<iter_policy_t> scanner_policies_t;
                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
                IteratorT first = first_;
                scanner_t scan(first, last);
                match<nil_t> hit = p.parse(scan);
                scan.skip(scan);
                return parse_info<IteratorT>(
                    first, hit, hit && (first == last),
                    hit.length());
            }
        };
    }
    template <typename IteratorT, typename ParserT, typename SkipT>
    inline parse_info<IteratorT>
    parse(
        IteratorT const& first,
        IteratorT const& last,
        parser<ParserT> const& p,
        parser<SkipT> const& skip)
    {
        return impl::phrase_parser<SkipT>::
            parse(first, last, p.derived(), skip.derived());
    }
    template <typename CharT, typename ParserT, typename SkipT>
    inline parse_info<CharT const*>
    parse(
        CharT const* str,
        parser<ParserT> const& p,
        parser<SkipT> const& skip)
    {
        CharT const* last = str;
        while (*last)
            last++;
        return parse(str, last, p, skip);
    }
}}
namespace boost { namespace spirit {
    template <typename BaseT>
    struct no_skipper_iteration_policy;
    template <typename BaseT>
    struct inhibit_case_iteration_policy;
    template <typename A, typename B>
    struct alternative;
    template <typename A, typename B>
    struct longest_alternative;
    template <typename A, typename B>
    struct shortest_alternative;
    namespace impl
    {
        template <typename RT, typename ST, typename ScannerT, typename BaseT>
        inline RT
        contiguous_parser_parse(
            ST const& s,
            ScannerT const& scan,
            skipper_iteration_policy<BaseT> const&)
        {
            typedef scanner_policies<
                no_skipper_iteration_policy<
                    typename ScannerT::iteration_policy_t>,
                typename ScannerT::match_policy_t,
                typename ScannerT::action_policy_t
            > policies_t;
            scan.skip(scan);
            RT hit = s.parse(scan.change_policies(policies_t(scan)));
            return hit;
        }
        template <typename RT, typename ST, typename ScannerT, typename BaseT>
        inline RT
        contiguous_parser_parse(
            ST const& s,
            ScannerT const& scan,
            no_skipper_iteration_policy<BaseT> const&)
        {
            return s.parse(scan);
        }
        template <typename RT, typename ST, typename ScannerT>
        inline RT
        contiguous_parser_parse(
            ST const& s,
            ScannerT const& scan,
            iteration_policy const&)
        {
            return s.parse(scan);
        }
        template <
            typename RT,
            typename ParserT,
            typename ScannerT,
            typename BaseT>
        inline RT
        implicit_lexeme_parse(
            ParserT const& p,
            ScannerT const& scan,
            skipper_iteration_policy<BaseT> const&)
        {
            typedef scanner_policies<
                no_skipper_iteration_policy<
                    typename ScannerT::iteration_policy_t>,
                typename ScannerT::match_policy_t,
                typename ScannerT::action_policy_t
            > policies_t;
            scan.skip(scan);
            RT hit = p.parse_main(scan.change_policies(policies_t(scan)));
            return hit;
        }
        template <
            typename RT,
            typename ParserT,
            typename ScannerT,
            typename BaseT>
        inline RT
        implicit_lexeme_parse(
            ParserT const& p,
            ScannerT const& scan,
            no_skipper_iteration_policy<BaseT> const&)
        {
            return p.parse_main(scan);
        }
        template <typename RT, typename ParserT, typename ScannerT>
        inline RT
        implicit_lexeme_parse(
            ParserT const& p,
            ScannerT const& scan,
            iteration_policy const&)
        {
            return p.parse_main(scan);
        }
        template <typename RT, typename ST, typename ScannerT>
        inline RT
        inhibit_case_parser_parse(
            ST const& s,
            ScannerT const& scan,
            iteration_policy const&)
        {
            typedef scanner_policies<
                inhibit_case_iteration_policy<
                    typename ScannerT::iteration_policy_t>,
                typename ScannerT::match_policy_t,
                typename ScannerT::action_policy_t
            > policies_t;
            return s.parse(scan.change_policies(policies_t(scan)));
        }
        template <typename RT, typename ST, typename ScannerT, typename BaseT>
        inline RT
        inhibit_case_parser_parse(
            ST const& s,
            ScannerT const& scan,
            inhibit_case_iteration_policy<BaseT> const&)
        {
            return s.parse(scan);
        }
        template <typename T>
        struct to_longest_alternative
        {
            typedef T result_t;
            static result_t const&
            convert(T const& a)
            { return a; }
        };
        template <typename A, typename B>
        struct to_longest_alternative<alternative<A, B> >
        {
            typedef typename to_longest_alternative<A>::result_t a_t;
            typedef typename to_longest_alternative<B>::result_t b_t;
            typedef longest_alternative<a_t, b_t> result_t;
            static result_t
            convert(alternative<A, B> const& alt)
            {
                return result_t(
                    to_longest_alternative<A>::convert(alt.left()),
                    to_longest_alternative<B>::convert(alt.right()));
            }
        };
        template <typename T>
        struct to_shortest_alternative
        {
            typedef T result_t;
            static result_t const&
            convert(T const& a)
            { return a; }
        };
        template <typename A, typename B>
        struct to_shortest_alternative<alternative<A, B> >
        {
            typedef typename to_shortest_alternative<A>::result_t a_t;
            typedef typename to_shortest_alternative<B>::result_t b_t;
            typedef shortest_alternative<a_t, b_t> result_t;
            static result_t
            convert(alternative<A, B> const& alt)
            {
                return result_t(
                    to_shortest_alternative<A>::convert(alt.left()),
                    to_shortest_alternative<B>::convert(alt.right()));
            }
        };
    }
}}
namespace boost { namespace spirit {
    template <typename DerivedT>
    struct char_parser : public parser<DerivedT>
    {
        typedef DerivedT self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<
                ScannerT,
                typename ScannerT::value_t
            >::type type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::value_t value_t;
            typedef typename ScannerT::iterator_t iterator_t;
            if (!scan.at_end())
            {
                value_t ch = *scan;
                if (this->derived().test(ch))
                {
                    iterator_t save(scan.first);
                    ++scan;
                    return scan.create_match(1, ch, save, scan.first);
                }
            }
            return scan.no_match();
        }
    };
    template <typename PositiveT>
    struct negated_char_parser
    : public char_parser<negated_char_parser<PositiveT> >
    {
        typedef negated_char_parser<PositiveT> self_t;
        typedef PositiveT positive_t;
        negated_char_parser(positive_t const& p)
        : positive(p.derived()) {}
        template <typename T>
        bool test(T ch) const
        {
            return !positive.test(ch);
        }
        positive_t const positive;
    };
    template <typename ParserT>
    inline negated_char_parser<ParserT>
    operator~(char_parser<ParserT> const& p)
    {
        return negated_char_parser<ParserT>(p.derived());
    }
    template <typename ParserT>
    inline ParserT
    operator~(negated_char_parser<ParserT> const& n)
    {
        return n.positive;
    }
    template <typename CharT = char>
    struct chlit : public char_parser<chlit<CharT> >
    {
        chlit(CharT ch_)
        : ch(ch_) {}
        template <typename T>
        bool test(T ch_) const
        {
            return ch_ == ch;
        }
        CharT ch;
    };
    template <typename CharT>
    inline chlit<CharT>
    ch_p(CharT ch)
    {
        return chlit<CharT>(ch);
    }
    template <typename CharT = char>
    struct range : public char_parser<range<CharT> >
    {
        range(CharT first_, CharT last_)
        : first(first_), last(last_)
        {
            ;
        }
        template <typename T>
        bool test(T ch) const
        {
            return !(CharT(ch) < first) && !(last < CharT(ch));
        }
        CharT first;
        CharT last;
    };
    template <typename CharT>
    inline range<CharT>
    range_p(CharT first, CharT last)
    {
        return range<CharT>(first, last);
    }
    template <typename IteratorT = char const*>
    class chseq : public parser<chseq<IteratorT> >
    {
    public:
        typedef chseq<IteratorT> self_t;
        chseq(IteratorT first_, IteratorT last_)
        : first(first_), last(last_) {}
        chseq(IteratorT first_)
        : first(first_), last(impl::get_last(first_)) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename boost::unwrap_reference<IteratorT>::type striter_t;
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            return impl::string_parser_parse<result_t>(
                striter_t(first),
                striter_t(last),
                scan);
        }
    private:
        IteratorT first;
        IteratorT last;
    };
    template <typename CharT>
    inline chseq<CharT const*>
    chseq_p(CharT const* str)
    {
        return chseq<CharT const*>(str);
    }
    template <typename IteratorT>
    inline chseq<IteratorT>
    chseq_p(IteratorT first, IteratorT last)
    {
        return chseq<IteratorT>(first, last);
    }
    template <typename IteratorT = char const*>
    class strlit : public parser<strlit<IteratorT> >
    {
    public:
        typedef strlit<IteratorT> self_t;
        strlit(IteratorT first, IteratorT last)
        : seq(first, last) {}
        strlit(IteratorT first)
        : seq(first) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            return impl::contiguous_parser_parse<result_t>
                (seq, scan, scan);
        }
    private:
        chseq<IteratorT> seq;
    };
    template <typename CharT>
    inline strlit<CharT const*>
    str_p(CharT const* str)
    {
        return strlit<CharT const*>(str);
    }
    template <typename IteratorT>
    inline strlit<IteratorT>
    str_p(IteratorT first, IteratorT last)
    {
        return strlit<IteratorT>(first, last);
    }
    struct nothing_parser : public parser<nothing_parser>
    {
        typedef nothing_parser self_t;
        nothing_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            return scan.no_match();
        }
    };
    nothing_parser const nothing_p = nothing_parser();
    struct anychar_parser : public char_parser<anychar_parser>
    {
        typedef anychar_parser self_t;
        anychar_parser() {}
        template <typename CharT>
        bool test(CharT) const
        {
            return true;
        }
    };
    anychar_parser const anychar_p = anychar_parser();
    inline nothing_parser
    operator~(anychar_parser)
    {
        return nothing_p;
    }
    struct alnum_parser : public char_parser<alnum_parser>
    {
        typedef alnum_parser self_t;
        alnum_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isalnum_(ch);
        }
    };
    alnum_parser const alnum_p = alnum_parser();
    struct alpha_parser : public char_parser<alpha_parser>
    {
        typedef alpha_parser self_t;
        alpha_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isalpha_(ch);
        }
    };
    alpha_parser const alpha_p = alpha_parser();
    struct cntrl_parser : public char_parser<cntrl_parser>
    {
        typedef cntrl_parser self_t;
        cntrl_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::iscntrl_(ch);
        }
    };
    cntrl_parser const cntrl_p = cntrl_parser();
    struct digit_parser : public char_parser<digit_parser>
    {
        typedef digit_parser self_t;
        digit_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isdigit_(ch);
        }
    };
    digit_parser const digit_p = digit_parser();
    struct graph_parser : public char_parser<graph_parser>
    {
        typedef graph_parser self_t;
        graph_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isgraph_(ch);
        }
    };
    graph_parser const graph_p = graph_parser();
    struct lower_parser : public char_parser<lower_parser>
    {
        typedef lower_parser self_t;
        lower_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::islower_(ch);
        }
    };
    lower_parser const lower_p = lower_parser();
    struct print_parser : public char_parser<print_parser>
    {
        typedef print_parser self_t;
        print_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isprint_(ch);
        }
    };
    print_parser const print_p = print_parser();
    struct punct_parser : public char_parser<punct_parser>
    {
        typedef punct_parser self_t;
        punct_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::ispunct_(ch);
        }
    };
    punct_parser const punct_p = punct_parser();
    struct blank_parser : public char_parser<blank_parser>
    {
        typedef blank_parser self_t;
        blank_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isblank_(ch);
        }
    };
    blank_parser const blank_p = blank_parser();
    struct space_parser : public char_parser<space_parser>
    {
        typedef space_parser self_t;
        space_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isspace_(ch);
        }
    };
    space_parser const space_p = space_parser();
    struct upper_parser : public char_parser<upper_parser>
    {
        typedef upper_parser self_t;
        upper_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isupper_(ch);
        }
    };
    upper_parser const upper_p = upper_parser();
    struct xdigit_parser : public char_parser<xdigit_parser>
    {
        typedef xdigit_parser self_t;
        xdigit_parser() {}
        template <typename CharT>
        bool test(CharT ch) const
        {
            return impl::isxdigit_(ch);
        }
    };
    xdigit_parser const xdigit_p = xdigit_parser();
    struct eol_parser : public parser<eol_parser>
    {
        typedef eol_parser self_t;
        eol_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typename ScannerT::iterator_t save = scan.first;
            std::size_t len = 0;
            if (!scan.at_end() && *scan == '\r')
            {
                ++scan;
                ++len;
            }
            if (!scan.at_end() && *scan == '\n')
            {
                ++scan;
                ++len;
            }
            if (len)
                return scan.create_match(len, nil_t(), save, scan.first);
            return scan.no_match();
        }
    };
    eol_parser const eol_p = eol_parser();
    struct end_parser : public parser<end_parser>
    {
        typedef end_parser self_t;
        end_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            if (scan.at_end())
                return scan.empty_match();
            return scan.no_match();
        }
    };
    end_parser const end_p = end_parser();
    inline strlit<char const*> const
    pizza_p(char const* your_favorite_pizza)
    {
        return your_favorite_pizza;
    }
}}
namespace boost {
template< typename T > struct is_const : mpl::bool_< ::boost::detail::cv_traits_imp<T*>::is_const > { };
template< typename T > struct is_const< T& > : mpl::bool_< false > { };
}
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_assign_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, false >::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value);
};
}
template< typename T > struct has_trivial_assign : mpl::bool_< ::boost::detail::has_trivial_assign_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_ctor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, false >::value);
};
}
template< typename T > struct has_trivial_constructor : mpl::bool_< ::boost::detail::has_trivial_ctor_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct has_trivial_dtor_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, false >::value);
};
}
template< typename T > struct has_trivial_destructor : mpl::bool_< ::boost::detail::has_trivial_dtor_impl<T>::value > { };
}
namespace boost {
template< typename T > struct has_nothrow_constructor : mpl::bool_< ::boost::has_trivial_constructor<T>::value > { };
}
namespace boost {
template< typename T > struct has_nothrow_assign : mpl::bool_< ::boost::has_trivial_assign<T>::value > { };
}
namespace boost {
template< typename T, typename U > struct is_same : mpl::bool_< false > { };
template< typename T > struct is_same< T,T > : mpl::bool_< true > { };
}
namespace boost {
namespace detail {
template <typename B, typename D>
struct bd_helper
{
    template <typename T>
    static type_traits::yes_type check(D const volatile *, T);
    static type_traits::no_type check(B const volatile *, int);
};
template<typename B, typename D>
struct is_base_and_derived_impl2
{
    struct Host
    {
        operator B const volatile *() const;
        operator D const volatile *();
    };
    static const bool value = sizeof(bd_helper<B,D>::check(Host(), 0)) == sizeof(type_traits::yes_type);
};
template <typename B, typename D>
struct is_base_and_derived_impl3
{
    static const bool value = false;
};
template <bool ic1, bool ic2, bool iss>
struct is_base_and_derived_select
{
   template <class T, class U>
   struct rebind
   {
      typedef is_base_and_derived_impl3<T,U> type;
   };
};
template <>
struct is_base_and_derived_select<true,true,false>
{
   template <class T, class U>
   struct rebind
   {
      typedef is_base_and_derived_impl2<T,U> type;
   };
};
template <typename B, typename D>
struct is_base_and_derived_impl
{
    typedef typename remove_cv<B>::type ncvB;
    typedef typename remove_cv<D>::type ncvD;
    typedef is_base_and_derived_select<
       ::boost::is_class<B>::value,
       ::boost::is_class<D>::value,
       ::boost::is_same<B,D>::value> selector;
    typedef typename selector::template rebind<ncvB,ncvD> binder;
    typedef typename binder::type bound_type;
    static const bool value = bound_type::value;
};
}
template< typename Base, typename Derived > struct is_base_and_derived : mpl::bool_< (::boost::detail::is_base_and_derived_impl<Base,Derived>::value) > { };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : mpl::bool_< false > { };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : mpl::bool_< false > { };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : mpl::bool_< false > { };
}
namespace boost {
namespace detail {
template <typename T>
struct is_compound_impl
{
   static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value);
};
}
template< typename T > struct is_compound : mpl::bool_< ::boost::detail::is_compound_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct empty_helper_t1 : public T
{
    empty_helper_t1();
    int i[256];
};
struct empty_helper_t2 { int i[256]; };
template <typename T, bool is_a_class = false>
struct empty_helper
{
    static const bool value = false;
};
template <typename T>
struct empty_helper<T, true>
{
    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2));
};
template <typename T>
struct is_empty_impl
{
    typedef typename remove_cv<T>::type cvt;
    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , false >::value );
};
template<> struct is_empty_impl< void > { static const bool value = (false); };
template<> struct is_empty_impl< void const > { static const bool value = (false); };
template<> struct is_empty_impl< void volatile > { static const bool value = (false); };
template<> struct is_empty_impl< void const volatile > { static const bool value = (false); };
}
template< typename T > struct is_empty : mpl::bool_< ::boost::detail::is_empty_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct is_object_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value);
};
}
template< typename T > struct is_object : mpl::bool_< ::boost::detail::is_object_impl<T>::value > { };
}
namespace boost {
namespace detail {
template <typename T>
struct is_stateless_impl
{
  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value);
};
}
template< typename T > struct is_stateless : mpl::bool_< ::boost::detail::is_stateless_impl<T>::value > { };
}
namespace boost
{
template <class T1, class T2>
class compressed_pair;
namespace details
{
   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
   struct compressed_pair_switch;
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, false, false>
      {static const int value = 0;};
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, true, true>
      {static const int value = 3;};
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, true, false>
      {static const int value = 1;};
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, false, false, true>
      {static const int value = 2;};
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, true, true, true>
      {static const int value = 4;};
   template <class T1, class T2>
   struct compressed_pair_switch<T1, T2, true, false, false>
      {static const int value = 5;};
   template <class T1, class T2, int Version> class compressed_pair_imp;
   using std::swap;
   template <typename T>
   inline void cp_swap(T& t1, T& t2)
   {
      swap(t1, t2);
   }
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 0>
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}
      compressed_pair_imp(first_param_type x)
         : first_(x) {}
      compressed_pair_imp(second_param_type y)
         : second_(y) {}
      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}
      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}
      void swap(::boost::compressed_pair<T1, T2>& y)
      {
         cp_swap(first_, y.first());
         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
      second_type second_;
   };
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 1>
      : private T1
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_(y) {}
      compressed_pair_imp(first_param_type x)
         : first_type(x) {}
      compressed_pair_imp(second_param_type y)
         : second_(y) {}
      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}
      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}
      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         cp_swap(second_, y.second());
      }
   private:
      second_type second_;
   };
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 2>
      : private T2
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type y)
         : second_type(y), first_(x) {}
      compressed_pair_imp(first_param_type x)
         : first_(x) {}
      compressed_pair_imp(second_param_type y)
         : second_type(y) {}
      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}
      second_reference second() {return *this;}
      second_const_reference second() const {return *this;}
      void swap(::boost::compressed_pair<T1,T2>& y)
      {
         cp_swap(first_, y.first());
      }
   private:
      first_type first_;
   };
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 3>
      : private T1,
        private T2
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_type(x), second_type(y) {}
      compressed_pair_imp(first_param_type x)
         : first_type(x) {}
      compressed_pair_imp(second_param_type y)
         : second_type(y) {}
      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}
      second_reference second() {return *this;}
      second_const_reference second() const {return *this;}
      void swap(::boost::compressed_pair<T1,T2>&) {}
   };
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 4>
      : private T1
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type)
         : first_type(x) {}
      compressed_pair_imp(first_param_type x)
         : first_type(x) {}
      first_reference first() {return *this;}
      first_const_reference first() const {return *this;}
      second_reference second() {return *this;}
      second_const_reference second() const {return *this;}
      void swap(::boost::compressed_pair<T1,T2>&) {}
   private:
   };
   template <class T1, class T2>
   class compressed_pair_imp<T1, T2, 5>
   {
   public:
      typedef T1 first_type;
      typedef T2 second_type;
      typedef typename call_traits<first_type>::param_type first_param_type;
      typedef typename call_traits<second_type>::param_type second_param_type;
      typedef typename call_traits<first_type>::reference first_reference;
      typedef typename call_traits<second_type>::reference second_reference;
      typedef typename call_traits<first_type>::const_reference first_const_reference;
      typedef typename call_traits<second_type>::const_reference second_const_reference;
      compressed_pair_imp() {}
      compressed_pair_imp(first_param_type x, second_param_type y)
         : first_(x), second_(y) {}
      compressed_pair_imp(first_param_type x)
         : first_(x), second_(x) {}
      first_reference first() {return first_;}
      first_const_reference first() const {return first_;}
      second_reference second() {return second_;}
      second_const_reference second() const {return second_;}
      void swap(::boost::compressed_pair<T1, T2>& y)
      {
         cp_swap(first_, y.first());
         cp_swap(second_, y.second());
      }
   private:
      first_type first_;
      second_type second_;
   };
}
template <class T1, class T2>
class compressed_pair
   : private ::boost::details::compressed_pair_imp<T1, T2,
             ::boost::details::compressed_pair_switch<
                    T1,
                    T2,
                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
                    ::boost::is_empty<T1>::value,
                    ::boost::is_empty<T2>::value>::value>
{
private:
   typedef details::compressed_pair_imp<T1, T2,
             ::boost::details::compressed_pair_switch<
                    T1,
                    T2,
                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
                    ::boost::is_empty<T1>::value,
                    ::boost::is_empty<T2>::value>::value> base;
public:
   typedef T1 first_type;
   typedef T2 second_type;
   typedef typename call_traits<first_type>::param_type first_param_type;
   typedef typename call_traits<second_type>::param_type second_param_type;
   typedef typename call_traits<first_type>::reference first_reference;
   typedef typename call_traits<second_type>::reference second_reference;
   typedef typename call_traits<first_type>::const_reference first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
   explicit compressed_pair(first_param_type x) : base(x) {}
   explicit compressed_pair(second_param_type y) : base(y) {}
   first_reference first() {return base::first();}
   first_const_reference first() const {return base::first();}
   second_reference second() {return base::second();}
   second_const_reference second() const {return base::second();}
   void swap(compressed_pair& y) { base::swap(y); }
};
template <class T>
class compressed_pair<T, T>
   : private details::compressed_pair_imp<T, T,
             ::boost::details::compressed_pair_switch<
                    T,
                    T,
                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
                    ::boost::is_empty<T>::value,
                    ::boost::is_empty<T>::value>::value>
{
private:
   typedef details::compressed_pair_imp<T, T,
             ::boost::details::compressed_pair_switch<
                    T,
                    T,
                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
                    ::boost::is_empty<T>::value,
                    ::boost::is_empty<T>::value>::value> base;
public:
   typedef T first_type;
   typedef T second_type;
   typedef typename call_traits<first_type>::param_type first_param_type;
   typedef typename call_traits<second_type>::param_type second_param_type;
   typedef typename call_traits<first_type>::reference first_reference;
   typedef typename call_traits<second_type>::reference second_reference;
   typedef typename call_traits<first_type>::const_reference first_const_reference;
   typedef typename call_traits<second_type>::const_reference second_const_reference;
            compressed_pair() : base() {}
            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
   explicit
      compressed_pair(first_param_type x) : base(x) {}
   first_reference first() {return base::first();}
   first_const_reference first() const {return base::first();}
   second_reference second() {return base::second();}
   second_const_reference second() const {return base::second();}
   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
};
template <class T1, class T2>
inline
void
swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
{
   x.swap(y);
}
}
namespace boost { namespace spirit {
    template <typename S, typename BaseT>
    class unary : public BaseT
    {
    public:
        typedef BaseT base_t;
        typedef typename boost::call_traits<S>::param_type param_t;
        typedef typename boost::call_traits<S>::const_reference return_t;
        typedef S subject_t;
        typedef typename S::embed_t subject_embed_t;
        unary(param_t subj_)
        : base_t(), subj(subj_) {}
        unary(BaseT const& base, param_t subj_)
        : base_t(base), subj(subj_) {}
        return_t
        subject() const
        { return subj; }
    private:
        subject_embed_t subj;
    };
    template <typename A, typename B, typename BaseT>
    class binary : public BaseT
    {
    public:
        typedef BaseT base_t;
        typedef typename boost::call_traits<A>::param_type left_param_t;
        typedef typename boost::call_traits<A>::const_reference left_return_t;
        typedef typename boost::call_traits<B>::param_type right_param_t;
        typedef typename boost::call_traits<B>::const_reference right_return_t;
        typedef A left_t;
        typedef typename A::embed_t left_embed_t;
        typedef B right_t;
        typedef typename B::embed_t right_embed_t;
        binary(left_param_t a, right_param_t b)
        : base_t(), subj(a, b) {}
        left_return_t
        left() const
        { return subj.first(); }
        right_return_t
        right() const
        { return subj.second(); }
    private:
        boost::compressed_pair<left_embed_t, right_embed_t> subj;
    };
}}
namespace boost { namespace spirit {
    template <typename BaseT>
    struct no_skipper_iteration_policy : public BaseT
    {
        typedef BaseT base_t;
        no_skipper_iteration_policy()
        : BaseT() {}
        template <typename PolicyT>
        no_skipper_iteration_policy(PolicyT const& other)
        : BaseT(other) {}
        template <typename ScannerT>
        void
        skip(ScannerT const& ) const {}
    };
    struct lexeme_parser_gen;
    template <typename ParserT>
    struct contiguous
    : public unary<ParserT, parser<contiguous<ParserT> > >
    {
        typedef contiguous<ParserT> self_t;
        typedef unary_parser_category parser_category_t;
        typedef lexeme_parser_gen parser_generator_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        contiguous(ParserT const& p)
        : base_t(p) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            return impl::contiguous_parser_parse<result_t>
                (this->subject(), scan, scan);
        }
    };
    struct lexeme_parser_gen
    {
        template <typename ParserT>
        struct result {
            typedef contiguous<ParserT> type;
        };
        template <typename ParserT>
        static contiguous<ParserT>
        generate(parser<ParserT> const& subject)
        {
            return contiguous<ParserT>(subject.derived());
        }
        template <typename ParserT>
        contiguous<ParserT>
        operator[](parser<ParserT> const& subject) const
        {
            return contiguous<ParserT>(subject.derived());
        }
    };
    const lexeme_parser_gen lexeme_d = lexeme_parser_gen();
    template <typename ScannerT>
    struct lexeme_scanner
    {
        typedef scanner_policies<
            no_skipper_iteration_policy<
                typename ScannerT::iteration_policy_t>,
            typename ScannerT::match_policy_t,
            typename ScannerT::action_policy_t
        > policies_t;
        typedef typename
            rebind_scanner_policies<ScannerT, policies_t>::type type;
    };
    template <typename BaseT>
    struct inhibit_case_iteration_policy : public BaseT
    {
        typedef BaseT base_t;
        inhibit_case_iteration_policy()
        : BaseT() {}
        template <typename PolicyT>
        inhibit_case_iteration_policy(PolicyT const& other)
        : BaseT(other) {}
        template <typename CharT>
        CharT filter(CharT ch) const
        { return impl::tolower_(ch); }
    };
    struct inhibit_case_parser_gen;
    template <typename ParserT>
    struct inhibit_case
    : public unary<ParserT, parser<inhibit_case<ParserT> > >
    {
        typedef inhibit_case<ParserT> self_t;
        typedef unary_parser_category parser_category_t;
        typedef inhibit_case_parser_gen parser_generator_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        inhibit_case(ParserT const& p)
        : base_t(p) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            return impl::inhibit_case_parser_parse<result_t>
                (this->subject(), scan, scan);
        }
    };
    template <int N>
    struct inhibit_case_parser_gen_base
    {
        static inhibit_case<strlit<char const*> >
        generate(char const* str)
        { return inhibit_case<strlit<char const*> >(str); }
        static inhibit_case<strlit<wchar_t const*> >
        generate(wchar_t const* str)
        { return inhibit_case<strlit<wchar_t const*> >(str); }
        static inhibit_case<chlit<char> >
        generate(char ch)
        { return inhibit_case<chlit<char> >(ch); }
        static inhibit_case<chlit<wchar_t> >
        generate(wchar_t ch)
        { return inhibit_case<chlit<wchar_t> >(ch); }
        template <typename ParserT>
        static inhibit_case<ParserT>
        generate(parser<ParserT> const& subject)
        { return inhibit_case<ParserT>(subject.derived()); }
        inhibit_case<strlit<char const*> >
        operator[](char const* str) const
        { return inhibit_case<strlit<char const*> >(str); }
        inhibit_case<strlit<wchar_t const*> >
        operator[](wchar_t const* str) const
        { return inhibit_case<strlit<wchar_t const*> >(str); }
        inhibit_case<chlit<char> >
        operator[](char ch) const
        { return inhibit_case<chlit<char> >(ch); }
        inhibit_case<chlit<wchar_t> >
        operator[](wchar_t ch) const
        { return inhibit_case<chlit<wchar_t> >(ch); }
        template <typename ParserT>
        inhibit_case<ParserT>
        operator[](parser<ParserT> const& subject) const
        { return inhibit_case<ParserT>(subject.derived()); }
    };
    struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0>
    {
        inhibit_case_parser_gen() {}
    };
    const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen();
    const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen();
    template <typename ScannerT>
    struct as_lower_scanner
    {
        typedef scanner_policies<
            inhibit_case_iteration_policy<
                typename ScannerT::iteration_policy_t>,
            typename ScannerT::match_policy_t,
            typename ScannerT::action_policy_t
        > policies_t;
        typedef typename
            rebind_scanner_policies<ScannerT, policies_t>::type type;
    };
    struct longest_parser_gen;
    template <typename A, typename B>
    struct longest_alternative
    : public binary<A, B, parser<longest_alternative<A, B> > >
    {
        typedef longest_alternative<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef longest_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        longest_alternative(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typename ScannerT::iterator_t save = scan.first;
            result_t l = this->left().parse(scan);
            std::swap(scan.first, save);
            result_t r = this->right().parse(scan);
            if (l || r)
            {
                if (l.length() > r.length())
                {
                    scan.first = save;
                    return l;
                }
                return r;
            }
            return scan.no_match();
        }
    };
    struct longest_parser_gen
    {
        template <typename A, typename B>
        struct result {
            typedef typename
                impl::to_longest_alternative<alternative<A, B> >::result_t
            type;
        };
        template <typename A, typename B>
        static typename
        impl::to_longest_alternative<alternative<A, B> >::result_t
        generate(alternative<A, B> const& alt)
        {
            return impl::to_longest_alternative<alternative<A, B> >::
                convert(alt);
        }
        template <typename A, typename B>
        typename impl::to_longest_alternative<alternative<A, B> >::result_t
        operator[](alternative<A, B> const& alt) const
        {
            return impl::to_longest_alternative<alternative<A, B> >::
                convert(alt);
        }
    };
    const longest_parser_gen longest_d = longest_parser_gen();
    struct shortest_parser_gen;
    template <typename A, typename B>
    struct shortest_alternative
    : public binary<A, B, parser<shortest_alternative<A, B> > >
    {
        typedef shortest_alternative<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef shortest_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        shortest_alternative(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typename ScannerT::iterator_t save = scan.first;
            result_t l = this->left().parse(scan);
            std::swap(scan.first, save);
            result_t r = this->right().parse(scan);
            if (l || r)
            {
                if (l.length() < r.length())
                {
                    scan.first = save;
                    return l;
                }
                return r;
            }
            return scan.no_match();
        }
    };
    struct shortest_parser_gen
    {
        template <typename A, typename B>
        struct result {
            typedef typename
                impl::to_shortest_alternative<alternative<A, B> >::result_t
            type;
        };
        template <typename A, typename B>
        static typename
        impl::to_shortest_alternative<alternative<A, B> >::result_t
        generate(alternative<A, B> const& alt)
        {
            return impl::to_shortest_alternative<alternative<A, B> >::
                convert(alt);
        }
        template <typename A, typename B>
        typename impl::to_shortest_alternative<alternative<A, B> >::result_t
        operator[](alternative<A, B> const& alt) const
        {
            return impl::to_shortest_alternative<alternative<A, B> >::
                convert(alt);
        }
    };
    const shortest_parser_gen shortest_d = shortest_parser_gen();
    template <typename BoundsT>
    struct min_bounded_gen;
    template <typename ParserT, typename BoundsT>
    struct min_bounded
    : public unary<ParserT, parser<min_bounded<ParserT, BoundsT> > >
    {
        typedef min_bounded<ParserT, BoundsT> self_t;
        typedef unary_parser_category parser_category_t;
        typedef min_bounded_gen<BoundsT> parser_generator_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        min_bounded(ParserT const& p, BoundsT const& min__)
        : base_t(p)
        , min_(min__) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            result_t hit = this->subject().parse(scan);
            if (hit.value() < min_)
                return scan.no_match();
            return hit;
        }
        BoundsT min_;
    };
    template <typename BoundsT>
    struct min_bounded_gen
    {
        min_bounded_gen(BoundsT const& min__)
        : min_(min__) {}
        template <typename DerivedT>
        min_bounded<DerivedT, BoundsT>
        operator[](parser<DerivedT> const& p) const
        { return min_bounded<DerivedT, BoundsT>(p.derived(), min_); }
        BoundsT min_;
    };
    template <typename BoundsT>
    inline min_bounded_gen<BoundsT>
    min_limit_d(BoundsT const& min_)
    { return min_bounded_gen<BoundsT>(min_); }
    template <typename BoundsT>
    struct max_bounded_gen;
    template <typename ParserT, typename BoundsT>
    struct max_bounded
    : public unary<ParserT, parser<max_bounded<ParserT, BoundsT> > >
    {
        typedef max_bounded<ParserT, BoundsT> self_t;
        typedef unary_parser_category parser_category_t;
        typedef max_bounded_gen<BoundsT> parser_generator_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        max_bounded(ParserT const& p, BoundsT const& max__)
        : base_t(p)
        , max_(max__) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            result_t hit = this->subject().parse(scan);
            if (hit.value() > max_)
                return scan.no_match();
            return hit;
        }
        BoundsT max_;
    };
    template <typename BoundsT>
    struct max_bounded_gen
    {
        max_bounded_gen(BoundsT const& max__)
        : max_(max__) {}
        template <typename DerivedT>
        max_bounded<DerivedT, BoundsT>
        operator[](parser<DerivedT> const& p) const
        { return max_bounded<DerivedT, BoundsT>(p.derived(), max_); }
        BoundsT max_;
    };
    template <typename BoundsT>
    inline max_bounded_gen<BoundsT>
    max_limit_d(BoundsT const& max_)
    { return max_bounded_gen<BoundsT>(max_); }
    template <typename BoundsT>
    struct bounded_gen;
    template <typename ParserT, typename BoundsT>
    struct bounded
    : public unary<ParserT, parser<bounded<ParserT, BoundsT> > >
    {
        typedef bounded<ParserT, BoundsT> self_t;
        typedef unary_parser_category parser_category_t;
        typedef bounded_gen<BoundsT> parser_generator_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__)
        : base_t(p)
        , min_(min__)
        , max_(max__) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            result_t hit = this->subject().parse(scan);
            if (hit.value() < min_ || hit.value() > max_)
                return scan.no_match();
            return hit;
        }
        BoundsT min_, max_;
    };
    template <typename BoundsT>
    struct bounded_gen
    {
        bounded_gen(BoundsT const& min__, BoundsT const& max__)
        : min_(min__)
        , max_(max__) {}
        template <typename DerivedT>
        bounded<DerivedT, BoundsT>
        operator[](parser<DerivedT> const& p) const
        { return bounded<DerivedT, BoundsT>(p.derived(), min_, max_); }
        BoundsT min_, max_;
    };
    template <typename BoundsT>
    inline bounded_gen<BoundsT>
    limit_d(BoundsT const& min_, BoundsT const& max_)
    { return bounded_gen<BoundsT>(min_, max_); }
}}
#include <cmath>
namespace boost { namespace spirit {
    struct sign_parser;
    namespace impl
    {
        template <typename ScannerT>
        bool
        extract_sign(ScannerT const& scan, std::size_t& count)
        {
            count = 0;
            bool neg = *scan == '-';
            if (neg || (*scan == '+'))
            {
                ++scan;
                ++count;
                return neg;
            }
            return false;
        }
        template<const int Radix>
        struct radix_traits;
        template<>
        struct radix_traits<2>
        {
            template<typename CharT>
            static bool is_valid(CharT ch)
            {
                return ('0' == ch || '1' == ch);
            }
            template<typename CharT>
            static int digit(CharT ch)
            {
                return ch - '0';
            }
        };
        template<>
        struct radix_traits<8>
        {
            template<typename CharT>
            static bool is_valid(CharT ch)
            {
                return ('0' <= ch && ch <= '7');
            }
            template<typename CharT>
            static int digit(CharT ch)
            {
                return ch - '0';
            }
        };
        template<>
        struct radix_traits<10>
        {
            template<typename CharT>
            static bool is_valid(CharT ch)
            {
                return impl::isdigit_(ch);
            }
            template<typename CharT>
            static int digit(CharT ch)
            {
                return ch - '0';
            }
        };
        template<>
        struct radix_traits<16>
        {
            template<typename CharT>
            static bool is_valid(CharT ch)
            {
                return impl::isxdigit_(ch);
            }
            template<typename CharT>
            static int digit(CharT ch)
            {
                if (impl::isdigit_(ch))
                    return ch - '0';
                return impl::tolower_(ch) - 'a' + 10;
            }
        };
        template <int Radix>
        struct positive_accumulate
        {
            template <typename T>
            static bool check(T const& n, T const& prev)
            {
                return n < prev;
            }
            template <typename T, typename CharT>
            static void add(T& n, CharT ch)
            {
                n += radix_traits<Radix>::digit(ch);
            }
        };
        template <int Radix>
        struct negative_accumulate
        {
            template <typename T>
            static bool check(T const& n, T const& prev)
            {
                return n > prev;
            }
            template <typename T, typename CharT>
            static void add(T& n, CharT ch)
            {
                n -= radix_traits<Radix>::digit(ch);
            }
        };
        template <int Radix, typename Accumulate>
        struct extract_int_base
        {
            template <typename ScannerT, typename T>
            static bool
            f(ScannerT& scan, T& n)
            {
                T prev = n;
                n *= Radix;
                if (Accumulate::check(n, prev))
                    return false;
                prev = n;
                Accumulate::add(n, *scan);
                if (Accumulate::check(n, prev))
                    return false;
                return true;
            }
        };
        template <bool Bounded>
        struct extract_int_
        {
            template <
                int Radix,
                unsigned MinDigits,
                int MaxDigits,
                typename Accumulate
            >
            struct apply
            {
                typedef extract_int_base<Radix, Accumulate> base;
                typedef radix_traits<Radix> check;
                template <typename ScannerT, typename T>
                static bool
                f(ScannerT& scan, T& n, std::size_t& count)
                {
                    std::size_t i = 0;
                    for (; (i < MaxDigits) && !scan.at_end()
                        && check::is_valid(*scan);
                        ++i, ++scan, ++count)
                    {
                        if (!base::f(scan, n))
                            return false;
                    }
                    return i >= MinDigits;
                }
            };
        };
        template <>
        struct extract_int_<false>
        {
            template <
                int Radix,
                unsigned MinDigits,
                int MaxDigits,
                typename Accumulate
            >
            struct apply
            {
                typedef extract_int_base<Radix, Accumulate> base;
                typedef radix_traits<Radix> check;
                template <typename ScannerT, typename T>
                static bool
                f(ScannerT& scan, T& n, std::size_t& count)
                {
                    std::size_t i = 0;
                    for (; !scan.at_end() && check::is_valid(*scan);
                        ++i, ++scan, ++count)
                    {
                        if (!base::f(scan, n))
                            return false;
                    }
                    return i >= MinDigits;
                }
            };
        };
        template <
            int Radix, unsigned MinDigits, int MaxDigits,
            typename Accumulate = positive_accumulate<Radix>
        >
        struct extract_int
        {
            template <typename ScannerT, typename T>
            static bool
            f(ScannerT& scan, T& n, std::size_t& count)
            {
                return extract_int_<(MaxDigits >= 0)>::template
                    apply<Radix, MinDigits, MaxDigits, Accumulate>::
                        f(scan, n, count);
            }
        };
        template <
            typename T = unsigned,
            int Radix = 10,
            unsigned MinDigits = 1,
            int MaxDigits = -1
        >
        struct uint_parser_impl
            : parser<uint_parser_impl<T, Radix, MinDigits, MaxDigits> >
        {
            typedef uint_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
            template <typename ScannerT>
            struct result
            {
                typedef typename match_result<ScannerT, T>::type type;
            };
            template <typename ScannerT>
            typename parser_result<self_t, ScannerT>::type
            parse(ScannerT const& scan) const
            {
                if (!scan.at_end())
                {
                    T n = 0;
                    std::size_t count = 0;
                    typename ScannerT::iterator_t save = scan.first;
                    if (extract_int<Radix, MinDigits, MaxDigits>::
                        f(scan, n, count))
                    {
                        return scan.create_match(count, n, save, scan.first);
                    }
                }
                return scan.no_match();
            }
        };
        template <
            typename T = unsigned,
            int Radix = 10,
            unsigned MinDigits = 1,
            int MaxDigits = -1
        >
        struct int_parser_impl
            : parser<int_parser_impl<T, Radix, MinDigits, MaxDigits> >
        {
            typedef int_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
            template <typename ScannerT>
            struct result
            {
                typedef typename match_result<ScannerT, T>::type type;
            };
            template <typename ScannerT>
            typename parser_result<self_t, ScannerT>::type
            parse(ScannerT const& scan) const
            {
                typedef extract_int<Radix, MinDigits, MaxDigits,
                    negative_accumulate<Radix> > extract_int_neg_t;
                typedef extract_int<Radix, MinDigits, MaxDigits>
                    extract_int_pos_t;
                if (!scan.at_end())
                {
                    T n = 0;
                    std::size_t count = 0;
                    typename ScannerT::iterator_t save = scan.first;
                    bool hit = impl::extract_sign(scan, count);
                    if (hit)
                        hit = extract_int_neg_t::f(scan, n, count);
                    else
                        hit = extract_int_pos_t::f(scan, n, count);
                    if (hit)
                        return scan.create_match(count, n, save, scan.first);
                    else
                        scan.first = save;
                }
                return scan.no_match();
            }
        };
        template <typename RT, typename T, typename RealPoliciesT>
        struct real_parser_impl
        {
            typedef real_parser_impl<RT, T, RealPoliciesT> self_t;
            template <typename ScannerT>
            RT parse_main(ScannerT const& scan) const
            {
                if (scan.at_end())
                    return scan.no_match();
                typename ScannerT::iterator_t save = scan.first;
                typedef typename parser_result<sign_parser, ScannerT>::type
                    sign_match_t;
                typedef typename parser_result<chlit<>, ScannerT>::type
                    exp_match_t;
                sign_match_t sign_match = RealPoliciesT::parse_sign(scan);
                std::size_t count = sign_match ? sign_match.length() : 0;
                bool neg = sign_match.has_valid_attribute() ?
                                    sign_match.value() : false;
                RT n_match = RealPoliciesT::parse_n(scan);
                T n = n_match.has_valid_attribute() ?
                                    n_match.value() : T(0);
                bool got_a_number = n_match;
                exp_match_t e_hit;
                if (!got_a_number && !RealPoliciesT::allow_leading_dot)
                     return scan.no_match();
                else
                    count += n_match.length();
                if (neg)
                    n = -n;
                if (RealPoliciesT::parse_dot(scan))
                {
                    if (RT hit = RealPoliciesT::parse_frac_n(scan))
                    {
                        hit.value(hit.value()
                            * std::
                                pow(T(10), T(-hit.length())));
                        if (neg)
                            n -= hit.value();
                        else
                            n += hit.value();
                        count += hit.length() + 1;
                    }
                    else if (!got_a_number ||
                        !RealPoliciesT::allow_trailing_dot)
                        return scan.no_match();
                    e_hit = RealPoliciesT::parse_exp(scan);
                }
                else
                {
                    if (!got_a_number)
                        return scan.no_match();
                    e_hit = RealPoliciesT::parse_exp(scan);
                    if (RealPoliciesT::expect_dot && !e_hit)
                        return scan.no_match();
                }
                if (e_hit)
                {
                    if (RT e_n_hit = RealPoliciesT::parse_exp_n(scan))
                    {
                        n *= std::
                            pow(T(10), T(e_n_hit.value()));
                        count += e_n_hit.length() + e_hit.length();
                    }
                    else
                    {
                        return scan.no_match();
                    }
                }
                return scan.create_match(count, n, save, scan.first);
            }
            template <typename ScannerT>
            static RT parse(ScannerT const& scan)
            {
                static self_t this_;
                return impl::implicit_lexeme_parse<RT>(this_, scan, scan);
            }
        };
    }
}}
namespace boost { namespace spirit
{
    template <
        typename T = unsigned,
        int Radix = 10,
        unsigned MinDigits = 1,
        int MaxDigits = -1
    >
    struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits> >
    {
        typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, T>::type type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef impl::uint_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
            typedef typename parser_result<impl_t, ScannerT>::type result_t;
            return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
        }
    };
    template <
        typename T = unsigned,
        int Radix = 10,
        unsigned MinDigits = 1,
        int MaxDigits = -1
    >
    struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits> >
    {
        typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, T>::type type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef impl::int_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
            typedef typename parser_result<impl_t, ScannerT>::type result_t;
            return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
        }
    };
    int_parser<int> const
        int_p = int_parser<int>();
    uint_parser<unsigned> const
        uint_p = uint_parser<unsigned>();
    uint_parser<unsigned, 2> const
        bin_p = uint_parser<unsigned, 2>();
    uint_parser<unsigned, 8> const
        oct_p = uint_parser<unsigned, 8>();
    uint_parser<unsigned, 16> const
        hex_p = uint_parser<unsigned, 16>();
    namespace impl
    {
        template <typename ScannerT>
        bool extract_sign(ScannerT const& scan, std::size_t& count);
    }
    struct sign_parser : public parser<sign_parser>
    {
        typedef sign_parser self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, bool>::type type;
        };
        sign_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            if (!scan.at_end())
            {
                std::size_t length;
                typename ScannerT::iterator_t save(scan.first);
                bool neg = impl::extract_sign(scan, length);
                if (length)
                    return scan.create_match(1, neg, save, scan.first);
            }
            return scan.no_match();
        }
    };
    sign_parser const sign_p = sign_parser();
    template <typename T>
    struct ureal_parser_policies
    {
        static const bool allow_leading_dot = true;
        static const bool allow_trailing_dot = true;
        static const bool expect_dot = false;
        typedef uint_parser<T, 10, 1, -1> uint_parser_t;
        typedef int_parser<T, 10, 1, -1> int_parser_t;
        template <typename ScannerT>
        static typename match_result<ScannerT, nil_t>::type
        parse_sign(ScannerT& scan)
        {
            return scan.no_match();
        }
        template <typename ScannerT>
        static typename parser_result<uint_parser_t, ScannerT>::type
        parse_n(ScannerT& scan)
        {
            return uint_parser_t().parse(scan);
        }
        template <typename ScannerT>
        static typename parser_result<chlit<>, ScannerT>::type
        parse_dot(ScannerT& scan)
        {
            return ch_p('.').parse(scan);
        }
        template <typename ScannerT>
        static typename parser_result<uint_parser_t, ScannerT>::type
        parse_frac_n(ScannerT& scan)
        {
            return uint_parser_t().parse(scan);
        }
        template <typename ScannerT>
        static typename parser_result<chlit<>, ScannerT>::type
        parse_exp(ScannerT& scan)
        {
            return as_lower_d['e'].parse(scan);
        }
        template <typename ScannerT>
        static typename parser_result<int_parser_t, ScannerT>::type
        parse_exp_n(ScannerT& scan)
        {
            return int_parser_t().parse(scan);
        }
    };
    template <typename T>
    struct real_parser_policies : public ureal_parser_policies<T>
    {
        template <typename ScannerT>
        static typename parser_result<sign_parser, ScannerT>::type
        parse_sign(ScannerT& scan)
        {
            return sign_p.parse(scan);
        }
    };
    template <
        typename T = double,
        typename RealPoliciesT = ureal_parser_policies<T>
    >
    struct real_parser
    : public parser<real_parser<T, RealPoliciesT> >
    {
        typedef real_parser<T, RealPoliciesT> self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, T>::type type;
        };
        real_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            return impl::real_parser_impl<result_t, T, RealPoliciesT>::parse(scan);
        }
    };
    real_parser<double, ureal_parser_policies<double> > const
        ureal_p = real_parser<double, ureal_parser_policies<double> >();
    real_parser<double, real_parser_policies<double> > const
        real_p = real_parser<double, real_parser_policies<double> >();
    template <typename T>
    struct strict_ureal_parser_policies : public ureal_parser_policies<T>
    {
        static const bool expect_dot = true;
    };
    template <typename T>
    struct strict_real_parser_policies : public real_parser_policies<T>
    {
        static const bool expect_dot = true;
    };
    real_parser<double, strict_ureal_parser_policies<double> > const
        strict_ureal_p
            = real_parser<double, strict_ureal_parser_policies<double> >();
    real_parser<double, strict_real_parser_policies<double> > const
        strict_real_p
            = real_parser<double, strict_real_parser_policies<double> >();
}}
namespace boost
{
    namespace spirit
    {
    struct default_parser_context_base
    {
        template <typename DerivedT>
        struct aux {};
    };
    struct parser_context_base {};
    struct nil_t;
    template<typename ContextT> struct parser_context_linker;
    template<typename AttrT = nil_t>
    struct parser_context : parser_context_base
    {
        typedef AttrT attr_t;
        typedef default_parser_context_base base_t;
        typedef parser_context_linker<parser_context<AttrT> > context_linker_t;
        template <typename ParserT>
        parser_context(ParserT const&) {}
        template <typename ParserT, typename ScannerT>
        void
        pre_parse(ParserT const&, ScannerT const&) {}
        template <typename ResultT, typename ParserT, typename ScannerT>
        ResultT&
        post_parse(ResultT& hit, ParserT const&, ScannerT const&)
        { return hit; }
    };
    template <typename ContextT, typename DerivedT>
    struct context_aux : public ContextT::base_t::template aux<DerivedT> {};
    template<typename ScannerT>
    struct parser_scanner_linker : public ScannerT
    {
        parser_scanner_linker(ScannerT const scan_) : ScannerT(scan_) {}
    };
    template<typename ContextT>
    struct parser_context_linker : public ContextT
    {
        template <typename ParserT>
        parser_context_linker(ParserT const& p)
        : ContextT(p) {}
        template <typename ParserT, typename ScannerT>
        void pre_parse(ParserT const& p, ScannerT const& scan)
        { ContextT::pre_parse(p, scan); }
        template <typename ResultT, typename ParserT, typename ScannerT>
        ResultT&
        post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan)
        { return ContextT::post_parse(hit, p, scan); }
    };
    }
}
namespace boost { namespace spirit {
    template <typename FirstT, typename RestT>
    struct subrule_list;
    template <int ID, typename DefT, typename ContextT>
    struct subrule_parser;
    namespace impl {
        template <int N, typename ListT>
        struct get_subrule
        {
            typedef typename get_subrule<N, typename ListT::rest_t>::type type;
        };
        template <int ID, typename DefT, typename ContextT, typename RestT>
        struct get_subrule<
            ID,
            subrule_list<
                subrule_parser<ID, DefT, ContextT>,
                RestT> >
        {
            typedef DefT type;
        };
        template <int ID>
        struct get_subrule<ID, nil_t>
        {
            typedef nil_t type;
        };
        template <typename T1, typename T2>
        struct get_result_t {
            typedef typename mpl::if_<
                boost::is_same<T1, nil_t>, T2, T1
            >::type type;
        };
        template <int ID, typename ScannerT, typename ContextResultT>
        struct get_subrule_result
        {
            typedef typename
                impl::get_subrule<ID, typename ScannerT::list_t>::type
            parser_t;
            typedef typename parser_result<parser_t, ScannerT>::type
            def_result_t;
            typedef typename match_result<ScannerT, ContextResultT>::type
            context_result_t;
            typedef typename get_result_t<context_result_t, def_result_t>::type
            type;
        };
        template <typename DefT, typename ScannerT, typename ContextResultT>
        struct get_subrule_parser_result
        {
            typedef typename parser_result<DefT, ScannerT>::type
            def_result_t;
            typedef typename match_result<ScannerT, ContextResultT>::type
            context_result_t;
            typedef typename get_result_t<context_result_t, def_result_t>::type
            type;
        };
        template <typename SubruleT, int ID>
        struct same_subrule_id
        {
            static const bool value = (SubruleT::id == ID);
        };
        template <typename RT, typename ScannerT, int ID>
        struct parse_subrule
        {
            template <typename ListT>
            static void
            do_parse(RT& r, ScannerT const& scan, ListT const& list, mpl::true_)
            {
                r = list.first.rhs.parse(scan);
            }
            template <typename ListT>
            static void
            do_parse(RT& r, ScannerT const& scan, ListT const& list, mpl::false_)
            {
                typedef typename ListT::rest_t::first_t subrule_t;
                mpl::bool_<same_subrule_id<subrule_t, ID>::value> same_id;
                do_parse(r, scan, list.rest, same_id);
            }
            static void
            do_(RT& r, ScannerT const& scan)
            {
                typedef typename ScannerT::list_t::first_t subrule_t;
                mpl::bool_<same_subrule_id<subrule_t, ID>::value> same_id;
                do_parse(r, scan, scan.list, same_id);
            }
        };
}}}
namespace boost { namespace spirit {
    template <typename ScannerT, typename ListT>
    struct subrules_scanner : public ScannerT
    {
        typedef ScannerT scanner_t;
        typedef ListT list_t;
        typedef subrules_scanner<ScannerT, ListT> self_t;
        subrules_scanner(ScannerT const& scan, ListT const& list_)
        : ScannerT(scan), list(list_) {}
        template <typename PoliciesT>
        struct rebind_policies
        {
            typedef typename rebind_scanner_policies<ScannerT, PoliciesT>::type
                rebind_scanner;
            typedef subrules_scanner<rebind_scanner, ListT> type;
        };
        template <typename PoliciesT>
        subrules_scanner<
            typename rebind_scanner_policies<ScannerT, PoliciesT>::type,
            ListT>
        change_policies(PoliciesT const& policies) const
        {
            typedef subrules_scanner<
                typename
                    rebind_scanner_policies<ScannerT, PoliciesT>::type,
                ListT>
            subrules_scanner_t;
            return subrules_scanner_t(
                    ScannerT::change_policies(policies),
                    list);
        }
        template <typename IteratorT>
        struct rebind_iterator
        {
            typedef typename rebind_scanner_iterator<ScannerT, IteratorT>::type
                rebind_scanner;
            typedef subrules_scanner<rebind_scanner, ListT> type;
        };
        template <typename IteratorT>
        subrules_scanner<
            typename rebind_scanner_iterator<ScannerT, IteratorT>::type,
            ListT>
        change_iterator(IteratorT const& first, IteratorT const &last) const
        {
            typedef subrules_scanner<
                typename
                    rebind_scanner_iterator<ScannerT, IteratorT>::type,
                ListT>
            subrules_scanner_t;
            return subrules_scanner_t(
                    ScannerT::change_iterator(first, last),
                    list);
        }
        ListT const& list;
    };
    template <typename ScannerT, typename ListT>
    struct subrules_scanner_finder
    {
          typedef subrules_scanner<ScannerT, ListT> type;
    };
    template <typename ScannerT, typename ListT>
    struct subrules_scanner_finder<subrules_scanner<ScannerT, ListT>, ListT>
    {
          typedef subrules_scanner<ScannerT, ListT> type;
    };
    template <typename FirstT, typename RestT>
    struct subrule_list : public parser<subrule_list<FirstT, RestT> >
    {
        typedef subrule_list<FirstT, RestT> self_t;
        typedef FirstT first_t;
        typedef RestT rest_t;
        subrule_list(FirstT const& first_, RestT const& rest_)
        : first(first_), rest(rest_) {}
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<FirstT, ScannerT>::type type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename subrules_scanner_finder<ScannerT, self_t>::type
            subrules_scanner_t;
            subrules_scanner_t g_arg(scan, *this);
            return first.start.parse(g_arg);
        }
        template <int ID, typename DefT, typename ContextT>
        subrule_list<
            FirstT,
            subrule_list<
                subrule_parser<ID, DefT, ContextT>,
                RestT> >
        operator,(subrule_parser<ID, DefT, ContextT> const& rhs)
        {
            return subrule_list<
                FirstT,
                subrule_list<
                    subrule_parser<ID, DefT, ContextT>,
                    RestT> >(
                        first,
                        subrule_list<
                            subrule_parser<ID, DefT, ContextT>,
                            RestT>(rhs, rest));
        }
        FirstT first;
        RestT rest;
    };
    template <int ID, typename ContextT = parser_context<> >
    struct subrule;
    template <int ID, typename DefT, typename ContextT>
    struct subrule_parser
    : public parser<subrule_parser<ID, DefT, ContextT> >
    {
        typedef subrule_parser<ID, DefT, ContextT> self_t;
        typedef subrule<ID, ContextT> subrule_t;
        typedef DefT def_t;
        static const int id = ID;
        template <typename ScannerT>
        struct result
        {
            typedef typename
                impl::get_subrule_parser_result<
                    DefT, ScannerT, typename subrule_t::attr_t>::type type;
        };
        subrule_parser(subrule_t const& start_, DefT const& rhs_)
        : rhs(rhs_), start(start_) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef subrule_list<self_t, nil_t> list_t;
            typedef subrules_scanner<ScannerT, list_t> scanner_t;
            list_t list(*this, nil_t());
            scanner_t g_arg(scan, list);
            return start.parse(g_arg);
        }
        template <int ID2, typename DefT2, typename ContextT2>
        inline subrule_list<
            self_t,
            subrule_list<
                subrule_parser<ID2, DefT2, ContextT2>,
                nil_t> >
        operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
        {
            return subrule_list<
                self_t,
                subrule_list<
                    subrule_parser<ID2, DefT2, ContextT2>,
                    nil_t> >(
                        *this,
                        subrule_list<
                            subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
                                rhs, nil_t()));
        }
        typename DefT::embed_t rhs;
        subrule_t const& start;
    };
    template <int ID, typename ContextT>
    struct subrule
        : public parser<subrule<ID, ContextT> >
        , public ContextT::base_t
        , public context_aux<ContextT, subrule<ID, ContextT> >
    {
        typedef subrule<ID, ContextT> self_t;
        typedef subrule<ID, ContextT> const& embed_t;
        typedef typename ContextT::context_linker_t context_t;
        typedef typename context_t::attr_t attr_t;
        static const int id = ID;
        template <typename ScannerT>
        struct result
        {
            typedef typename
                impl::get_subrule_result<ID, ScannerT, attr_t>::type type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse_main(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            result_t result;
            impl::parse_subrule<result_t, ScannerT, ID>::
                do_(result, scan);
            return result;
        }
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef parser_scanner_linker<ScannerT> scanner_t;
            scanner_t scan_wrap(scan); context_t context_wrap(*this); context_wrap.pre_parse(*this, scan_wrap); result_t hit = parse_main(scan); return context_wrap.post_parse(hit, *this, scan_wrap);;
        }
        template <typename DefT>
        subrule_parser<ID, DefT, ContextT>
        operator=(parser<DefT> const& rhs) const
        {
            return subrule_parser<ID, DefT, ContextT>(*this, rhs.derived());
        }
    private:
        subrule& operator=(subrule const&);
        template <int ID2, typename ContextT2>
        subrule& operator=(subrule<ID2, ContextT2> const&);
    };
}}
typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( 1 > 0 ) >)> boost_static_assert_typedef_30;
#include <assert.h>
namespace boost
{
template<class T> inline void checked_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}
template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}
template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * x) const
    {
        boost::checked_delete(x);
    }
};
template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;
    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};
}
namespace boost
{
template<class T> class scoped_ptr
{
private:
    T * ptr;
    scoped_ptr(scoped_ptr const &);
    scoped_ptr & operator=(scoped_ptr const &);
    typedef scoped_ptr<T> this_type;
public:
    typedef T element_type;
    explicit scoped_ptr(T * p = 0): ptr(p)
    {
    }
    explicit scoped_ptr(std::auto_ptr<T> p): ptr(p.release())
    {
    }
    ~scoped_ptr()
    {
        boost::checked_delete(ptr);
    }
    void reset(T * p = 0)
    {
        ((void)0);
        this_type(p).swap(*this);
    }
    T & operator*() const
    {
        ((void)0);
        return *ptr;
    }
    T * operator->() const
    {
        ((void)0);
        return ptr;
    }
    T * get() const
    {
        return ptr;
    }
    typedef T * this_type::*unspecified_bool_type;
    operator unspecified_bool_type() const
    {
        return ptr == 0? 0: &this_type::ptr;
    }
    bool operator! () const
    {
        return ptr == 0;
    }
    void swap(scoped_ptr & b)
    {
        T * tmp = b.ptr;
        b.ptr = ptr;
        ptr = tmp;
    }
};
template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
{
    a.swap(b);
}
template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
{
    return p.get();
}
}
namespace boost { namespace spirit {
    namespace impl
    {
        template <typename BaseT, typename DefaultT
            , typename T0, typename T1, typename T2>
        struct get_param
        {
            typedef typename mpl::if_<
                is_base_and_derived<BaseT, T0>
              , T0
              , typename mpl::if_<
                    is_base_and_derived<BaseT, T1>
                  , T1
                  , typename mpl::if_<
                        is_base_and_derived<BaseT, T2>
                      , T2
                      , DefaultT
                    >::type
                >::type
            >::type type;
        };
        template <typename T0, typename T1, typename T2>
        struct get_context
        {
            typedef typename get_param<
                parser_context_base, parser_context<>, T0, T1, T2>::type
            type;
        };
        template <typename T0, typename T1, typename T2>
        struct get_tag
        {
            typedef typename get_param<
                parser_tag_base, parser_address_tag, T0, T1, T2>::type
            type;
        };
        template <typename T0, typename T1, typename T2>
        struct get_scanner
        {
            typedef typename get_param<
                scanner_base, scanner<>, T0, T1, T2>::type
            type;
        };
        template <
            typename DerivedT
          , typename EmbedT
          , typename T0 = nil_t
          , typename T1 = nil_t
          , typename T2 = nil_t
        >
        class rule_base;
        class rule_base_access
        {
            template <
                typename DerivedT
              , typename EmbedT
              , typename T0
              , typename T1
              , typename T2
            >
           friend class rule_base;
            template <typename RuleT>
            static typename RuleT::abstract_parser_t*
            get(RuleT const& r)
            {
                return r.get();
            }
        };
        template <
            typename DerivedT
          , typename EmbedT
          , typename T0
          , typename T1
          , typename T2
        >
        class rule_base
            : public parser<DerivedT>
            , public impl::get_context<T0, T1, T2>::type::base_t
            , public context_aux<
                typename impl::get_context<T0, T1, T2>::type, DerivedT>
            , public impl::get_tag<T0, T1, T2>::type
        {
        public:
            typedef typename impl::get_scanner<T0, T1, T2>::type scanner_t;
            typedef typename impl::get_context<T0, T1, T2>::type context_t;
            typedef typename impl::get_tag<T0, T1, T2>::type tag_t;
            typedef EmbedT embed_t;
            typedef typename context_t::context_linker_t linked_context_t;
            typedef typename linked_context_t::attr_t attr_t;
            template <typename ScannerT>
            struct result
            {
                typedef typename match_result<ScannerT, attr_t>::type type;
            };
            template <typename ScannerT>
            typename parser_result<DerivedT, ScannerT>::type
            parse(ScannerT const& scan) const
            {
                typedef parser_scanner_linker<ScannerT> linked_scanner_t;
                typedef typename parser_result<DerivedT, ScannerT>::type result_t;
                linked_scanner_t scan_wrap(scan); linked_context_t context_wrap(*this); context_wrap.pre_parse(*this, scan_wrap); result_t hit = parse_main(scan); return context_wrap.post_parse(hit, *this, scan_wrap);;
            }
            template <typename ScannerT>
            typename parser_result<DerivedT, ScannerT>::type
            parse_main(ScannerT const& scan) const
            {
                typename parser_result<DerivedT, ScannerT>::type hit;
                DerivedT const * derivedThis =
                    static_cast<DerivedT const *>(this);
                if (rule_base_access::get(*derivedThis))
                {
                    typename ScannerT::iterator_t s(scan.first);
                    hit = rule_base_access::get(*derivedThis)
                            ->do_parse_virtual(scan);
                    scan.group_match(hit, this->id(), s, scan.first);
                }
                else
                {
                    hit = scan.no_match();
                }
                return hit;
            }
        };
        template <typename ScannerT, typename AttrT>
        struct abstract_parser
        {
            abstract_parser() {}
            virtual ~abstract_parser() {}
            virtual typename match_result<ScannerT, AttrT>::type
            do_parse_virtual(ScannerT const& scan) const = 0;
            virtual abstract_parser*
            clone() const = 0;
        };
        template <typename ParserT, typename ScannerT, typename AttrT>
        struct concrete_parser : abstract_parser<ScannerT, AttrT>
        {
            concrete_parser(ParserT const& p) : p(p) {}
            virtual ~concrete_parser() {}
            virtual typename match_result<ScannerT, AttrT>::type
            do_parse_virtual(ScannerT const& scan) const
            {
                return p.parse(scan);
            }
            virtual abstract_parser<ScannerT, AttrT>*
            clone() const
            {
                return new concrete_parser(p);
            }
            typename ParserT::embed_t p;
        };
    }
}}
namespace boost { namespace spirit {
    template <
        typename T0 = nil_t
      , typename T1 = nil_t
      , typename T2 = nil_t
    >
    class rule
        : public impl::rule_base<
            rule<T0, T1, T2>
          , rule<T0, T1, T2> const&
          , T0, T1, T2>
    {
    public:
        typedef rule<T0, T1, T2> self_t;
        typedef impl::rule_base<
            self_t
          , self_t const&
          , T0, T1, T2>
        base_t;
        typedef typename base_t::scanner_t scanner_t;
        typedef typename base_t::attr_t attr_t;
        typedef impl::abstract_parser<scanner_t, attr_t> abstract_parser_t;
        rule() : ptr() {}
        ~rule() {}
        rule(rule const& r)
        : ptr(new impl::concrete_parser<rule, scanner_t, attr_t>(r)) {}
        template <typename ParserT>
        rule(ParserT const& p)
        : ptr(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p)) {}
        template <typename ParserT>
        rule& operator=(ParserT const& p)
        {
            ptr.reset(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p));
            return *this;
        }
        rule& operator=(rule const& r)
        {
            ptr.reset(new impl::concrete_parser<rule, scanner_t, attr_t>(r));
            return *this;
        }
        rule<T0, T1, T2>
        copy() const
        {
            return rule<T0, T1, T2>(ptr.get() ? ptr->clone() : 0);
        }
    private:
        friend class impl::rule_base_access;
        abstract_parser_t*
        get() const
        {
            return ptr.get();
        }
        rule(abstract_parser_t const* ptr)
        : ptr(ptr) {}
        scoped_ptr<abstract_parser_t> ptr;
    };
}}
#include <assert.h>
#include <pthread.h>
namespace boost
{
namespace detail
{
class lightweight_mutex
{
private:
    pthread_mutex_t m_;
    lightweight_mutex(lightweight_mutex const &);
    lightweight_mutex & operator=(lightweight_mutex const &);
public:
    lightweight_mutex()
    {
        pthread_mutex_init(&m_, 0);
    }
    ~lightweight_mutex()
    {
        pthread_mutex_destroy(&m_);
    }
    class scoped_lock;
    friend class scoped_lock;
    class scoped_lock
    {
    private:
        pthread_mutex_t & m_;
        scoped_lock(scoped_lock const &);
        scoped_lock & operator=(scoped_lock const &);
    public:
        scoped_lock(lightweight_mutex & m): m_(m.m_)
        {
            pthread_mutex_lock(&m_);
        }
        ~scoped_lock()
        {
            pthread_mutex_unlock(&m_);
        }
    };
};
}
}
namespace boost
{
class bad_weak_ptr: public std::exception
{
public:
    virtual char const * what() const throw()
    {
        return "boost::bad_weak_ptr";
    }
};
namespace detail
{
class sp_counted_base
{
private:
    typedef detail::lightweight_mutex mutex_type;
public:
    sp_counted_base(): use_count_(1), weak_count_(1)
    {
    }
    virtual ~sp_counted_base()
    {
    }
    virtual void dispose() = 0;
    virtual void destruct()
    {
        delete this;
    }
    virtual void * get_deleter(std::type_info const & ti) = 0;
    void add_ref_copy()
    {
        mutex_type::scoped_lock lock(mtx_);
        ++use_count_;
    }
    void add_ref_lock()
    {
        mutex_type::scoped_lock lock(mtx_);
        if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr());
        ++use_count_;
    }
    void release()
    {
        {
            mutex_type::scoped_lock lock(mtx_);
            long new_use_count = --use_count_;
            if(new_use_count != 0) return;
        }
        dispose();
        weak_release();
    }
    void weak_add_ref()
    {
        mutex_type::scoped_lock lock(mtx_);
        ++weak_count_;
    }
    void weak_release()
    {
        long new_weak_count;
        {
            mutex_type::scoped_lock lock(mtx_);
            new_weak_count = --weak_count_;
        }
        if(new_weak_count == 0)
        {
            destruct();
        }
    }
    long use_count() const
    {
        mutex_type::scoped_lock lock(mtx_);
        return use_count_;
    }
private:
    sp_counted_base(sp_counted_base const &);
    sp_counted_base & operator= (sp_counted_base const &);
    long use_count_;
    long weak_count_;
    mutable mutex_type mtx_;
};
template<class P, class D> class sp_counted_base_impl: public sp_counted_base
{
private:
    P ptr;
    D del;
    sp_counted_base_impl(sp_counted_base_impl const &);
    sp_counted_base_impl & operator= (sp_counted_base_impl const &);
    typedef sp_counted_base_impl<P, D> this_type;
public:
    sp_counted_base_impl(P p, D d): ptr(p), del(d)
    {
    }
    virtual void dispose()
    {
        del(ptr);
    }
    virtual void * get_deleter(std::type_info const & ti)
    {
        return ti == typeid(D)? &del: 0;
    }
};
class weak_count;
class shared_count
{
private:
    sp_counted_base * pi_;
    friend class weak_count;
public:
    shared_count(): pi_(0)
    {
    }
    template<class P, class D> shared_count(P p, D d): pi_(0)
    {
        try
        {
            pi_ = new sp_counted_base_impl<P, D>(p, d);
        }
        catch(...)
        {
            d(p);
            throw;
        }
    }
    template<class Y>
    explicit shared_count(std::auto_ptr<Y> & r): pi_(new sp_counted_base_impl< Y *, checked_deleter<Y> >(r.get(), checked_deleter<Y>()))
    {
        r.release();
    }
    ~shared_count()
    {
        if(pi_ != 0) pi_->release();
    }
    shared_count(shared_count const & r): pi_(r.pi_)
    {
        if(pi_ != 0) pi_->add_ref_copy();
    }
    explicit shared_count(weak_count const & r);
    shared_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;
        if(tmp != 0) tmp->add_ref_copy();
        if(pi_ != 0) pi_->release();
        pi_ = tmp;
        return *this;
    }
    void swap(shared_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }
    bool unique() const
    {
        return use_count() == 1;
    }
    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
    void * get_deleter(std::type_info const & ti) const
    {
        return pi_? pi_->get_deleter(ti): 0;
    }
};
class weak_count
{
private:
    sp_counted_base * pi_;
    friend class shared_count;
public:
    weak_count(): pi_(0)
    {
    }
    weak_count(shared_count const & r): pi_(r.pi_)
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
    weak_count(weak_count const & r): pi_(r.pi_)
    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();
    }
    weak_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;
        if(tmp != 0) tmp->weak_add_ref();
        if(pi_ != 0) pi_->weak_release();
        pi_ = tmp;
        return *this;
    }
    weak_count & operator= (weak_count const & r)
    {
        sp_counted_base * tmp = r.pi_;
        if(tmp != 0) tmp->weak_add_ref();
        if(pi_ != 0) pi_->weak_release();
        pi_ = tmp;
        return *this;
    }
    void swap(weak_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }
    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }
    friend inline bool operator==(weak_count const & a, weak_count const & b)
    {
        return a.pi_ == b.pi_;
    }
    friend inline bool operator<(weak_count const & a, weak_count const & b)
    {
        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
    }
};
inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
{
    if(pi_ != 0)
    {
        pi_->add_ref_lock();
    }
    else
    {
        boost::throw_exception(boost::bad_weak_ptr());
    }
}
}
}
namespace boost
{
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
namespace detail
{
struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct polymorphic_cast_tag {};
template<class T> struct shared_ptr_traits
{
    typedef T & reference;
};
template<> struct shared_ptr_traits<void>
{
    typedef void reference;
};
template<> struct shared_ptr_traits<void const>
{
    typedef void reference;
};
template<> struct shared_ptr_traits<void volatile>
{
    typedef void reference;
};
template<> struct shared_ptr_traits<void const volatile>
{
    typedef void reference;
};
template<class T, class Y> void sp_enable_shared_from_this(boost::enable_shared_from_this<T> * pe, Y * px, shared_count const & pn)
{
    if(pe != 0) pe->_internal_weak_this._internal_assign(px, pn);
}
inline void sp_enable_shared_from_this(void const volatile *, void const volatile *, shared_count const &)
{
}
}
template<class T> class shared_ptr
{
private:
    typedef shared_ptr<T> this_type;
public:
    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename detail::shared_ptr_traits<T>::reference reference;
    shared_ptr(): px(0), pn()
    {
    }
    template<class Y>
    explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>())
    {
        detail::sp_enable_shared_from_this(p, p, pn);
    }
    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        detail::sp_enable_shared_from_this(p, p, pn);
    }
    shared_ptr & operator=(shared_ptr const & r)
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
    {
        px = r.px;
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn)
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
    {
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            pn = detail::shared_count();
        }
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }
    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = detail::shared_count(r);
        detail::sp_enable_shared_from_this(tmp, tmp, pn);
    }
    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r)
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
    template<class Y>
    shared_ptr & operator=(std::auto_ptr<Y> & r)
    {
        this_type(r).swap(*this);
        return *this;
    }
    void reset()
    {
        this_type().swap(*this);
    }
    template<class Y> void reset(Y * p)
    {
        ((void)0);
        this_type(p).swap(*this);
    }
    template<class Y, class D> void reset(Y * p, D d)
    {
        this_type(p, d).swap(*this);
    }
    reference operator* () const
    {
        ((void)0);
        return *px;
    }
    T * operator-> () const
    {
        ((void)0);
        return px;
    }
    T * get() const
    {
        return px;
    }
    typedef T * this_type::*unspecified_bool_type;
    operator unspecified_bool_type() const
    {
        return px == 0? 0: &this_type::px;
    }
    bool operator! () const
    {
        return px == 0;
    }
    bool unique() const
    {
        return pn.unique();
    }
    long use_count() const
    {
        return pn.use_count();
    }
    void swap(shared_ptr<T> & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }
    void * _internal_get_deleter(std::type_info const & ti) const
    {
        return pn.get_deleter(ti);
    }
private:
    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;
    T * px;
    detail::shared_count pn;
};
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}
template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() != b.get();
}
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a._internal_less(b);
}
template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
{
    a.swap(b);
}
template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::static_cast_tag());
}
template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::const_cast_tag());
}
template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::dynamic_cast_tag());
}
template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::static_cast_tag());
}
template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::dynamic_cast_tag());
}
template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, detail::polymorphic_cast_tag());
}
template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
{
    ((void)0);
    return shared_static_cast<T>(r);
}
template<class T> inline T * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
{
    os << p.get();
    return os;
}
template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
}
}
namespace boost { namespace spirit {
    namespace impl {
        template <typename IdT = std::size_t>
        struct object_with_id_base_supply
        {
            typedef IdT object_id;
            typedef std::vector<object_id> id_vector;
            object_with_id_base_supply() : max_id(object_id()) {}
            object_id max_id;
            id_vector free_ids;
            object_id acquire();
            void release(object_id);
        };
        template <typename TagT, typename IdT = std::size_t>
        struct object_with_id_base
        {
            typedef TagT tag_t;
            typedef IdT object_id;
        protected:
            object_id acquire_object_id();
            void release_object_id(object_id);
        private:
            boost::shared_ptr<object_with_id_base_supply<IdT> > id_supply;
        };
        template<class TagT, typename IdT = std::size_t>
        struct object_with_id : private object_with_id_base<TagT, IdT>
        {
            typedef object_with_id<TagT, IdT> self_t;
            typedef object_with_id_base<TagT, IdT> base_t;
            typedef IdT object_id;
            object_with_id() : id(base_t::acquire_object_id()) {}
            object_with_id(self_t const &other)
                : base_t(other)
                , id(base_t::acquire_object_id())
            {}
            self_t &operator = (self_t const &other)
            {
                base_t::operator=(other);
                return *this;
            }
            ~object_with_id() { base_t::release_object_id(id); }
            object_id get_object_id() const { return id; }
        private:
            object_id const id;
        };
        template <typename IdT>
        inline IdT
        object_with_id_base_supply<IdT>::acquire()
        {
            if (free_ids.size())
            {
                object_id id = *free_ids.rbegin();
                free_ids.pop_back();
                return id;
            }
            else
            {
                if (free_ids.capacity()<=max_id)
                    free_ids.reserve(max_id*3/2+1);
                return ++max_id;
            }
        }
        template <typename IdT>
        inline void
        object_with_id_base_supply<IdT>::release(IdT id)
        {
            if (max_id == id)
                max_id--;
            else
                free_ids.push_back(id);
        }
        template <typename TagT, typename IdT>
        inline IdT
        object_with_id_base<TagT, IdT>::acquire_object_id()
        {
            {
                static boost::shared_ptr<object_with_id_base_supply<IdT> >
                    static_supply;
                if (!static_supply.get())
                    static_supply.reset(new object_with_id_base_supply<IdT>());
                id_supply = static_supply;
            }
            return id_supply->acquire();
        }
        template <typename TagT, typename IdT>
        inline void
        object_with_id_base<TagT, IdT>::release_object_id(IdT id)
        {
            id_supply->release(id);
        }
    }
}}
namespace boost
{
template<class T> class weak_ptr
{
private:
    typedef weak_ptr<T> this_type;
public:
    typedef T element_type;
    weak_ptr(): px(0), pn()
    {
    }
    template<class Y>
    weak_ptr(weak_ptr<Y> const & r): pn(r.pn)
    {
        px = r.lock().get();
    }
    template<class Y>
    weak_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn)
    {
    }
    template<class Y>
    weak_ptr & operator=(weak_ptr<Y> const & r)
    {
        px = r.lock().get();
        pn = r.pn;
        return *this;
    }
    template<class Y>
    weak_ptr & operator=(shared_ptr<Y> const & r)
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
    shared_ptr<T> lock() const
    {
        if(expired())
        {
            return shared_ptr<element_type>();
        }
        try
        {
            return shared_ptr<element_type>(*this);
        }
        catch(bad_weak_ptr const &)
        {
            return shared_ptr<element_type>();
        }
    }
    long use_count() const
    {
        return pn.use_count();
    }
    bool expired() const
    {
        return pn.use_count() == 0;
    }
    void reset()
    {
        this_type().swap(*this);
    }
    void swap(this_type & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    void _internal_assign(T * px2, detail::shared_count const & pn2)
    {
        px = px2;
        pn = pn2;
    }
    template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
    {
        return pn < rhs.pn;
    }
private:
    template<class Y> friend class weak_ptr;
    template<class Y> friend class shared_ptr;
    T * px;
    detail::weak_count pn;
};
template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
{
    return a._internal_less(b);
}
template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
{
    a.swap(b);
}
template<class T> shared_ptr<T> make_shared(weak_ptr<T> const & r)
{
    return r.lock();
}
}
namespace boost { namespace spirit {
template <typename DerivedT, typename ContextT>
struct grammar;
template <typename GrammarT, typename ScannerT>
struct grammar_definition
{
    typedef typename GrammarT::template definition<ScannerT> type;
};
    namespace impl
    {
    struct grammar_tag {};
    template <typename GrammarT>
    struct grammar_helper_base
    {
        virtual int undefine(GrammarT *) = 0;
        virtual ~grammar_helper_base() {}
    };
    template <typename GrammarT>
    struct grammar_helper_list
    {
        typedef GrammarT grammar_t;
        typedef grammar_helper_base<GrammarT> helper_t;
        typedef std::vector<helper_t*> vector_t;
        grammar_helper_list() {}
        grammar_helper_list(grammar_helper_list const& x)
        {
        }
        grammar_helper_list& operator=(grammar_helper_list const& x)
        {
            return *this;
        }
        void push_back(helper_t *helper)
        { helpers.push_back(helper); }
        void pop_back()
        { helpers.pop_back(); }
        typename vector_t::size_type
        size() const
        { return helpers.size(); }
        typename vector_t::reverse_iterator
        rbegin()
        { return helpers.rbegin(); }
        typename vector_t::reverse_iterator
        rend()
        { return helpers.rend(); }
    private:
        vector_t helpers;
    };
    struct grammartract_helper_list;
    struct grammartract_helper_list
    {
        template<typename GrammarT>
        static grammar_helper_list<GrammarT>&
        do_(GrammarT const* g)
        {
            return g->helpers;
        }
    };
    template <typename GrammarT, typename DerivedT, typename ScannerT>
    struct grammar_helper : private grammar_helper_base<GrammarT>
    {
        typedef GrammarT grammar_t;
        typedef ScannerT scanner_t;
        typedef DerivedT derived_t;
        typedef typename grammar_definition<DerivedT, ScannerT>::type definition_t;
        typedef grammar_helper<grammar_t, derived_t, scanner_t> helper_t;
        typedef boost::shared_ptr<helper_t> helper_ptr_t;
        typedef boost::weak_ptr<helper_t> helper_weak_ptr_t;
        grammar_helper*
        this_() { return this; }
        grammar_helper(helper_weak_ptr_t& p)
        : definitions_cnt(0)
        , self(this_())
        { p = self; }
        definition_t&
        define(grammar_t const* target_grammar)
        {
            grammar_helper_list<GrammarT> &helpers =
                grammartract_helper_list::do_(target_grammar);
            typename grammar_t::object_id id = target_grammar->get_object_id();
            if (definitions.size()<=id)
                definitions.resize(id*3/2+1);
            if (definitions[id]!=0)
                return *definitions[id];
            std::auto_ptr<definition_t>
                result(new definition_t(target_grammar->derived()));
            helpers.push_back(this);
            ++definitions_cnt;
            definitions[id] = result.get();
            return *(result.release());
        }
        int
        undefine(grammar_t* target_grammar)
        {
            typename grammar_t::object_id id = target_grammar->get_object_id();
            if (definitions.size()<=id)
                return 0;
            delete definitions[id];
            definitions[id] = 0;
            if (--definitions_cnt==0)
                self.reset();
            return 0;
        }
    private:
        std::vector<definition_t*> definitions;
        unsigned long definitions_cnt;
        helper_ptr_t self;
    };
    template<typename DerivedT, typename ContextT, typename ScannerT>
    inline typename DerivedT::template definition<ScannerT> &
    get_definition(grammar<DerivedT, ContextT> const* self)
    {
        typedef grammar<DerivedT, ContextT> self_t;
        typedef impl::grammar_helper<self_t, DerivedT, ScannerT> helper_t;
        typedef typename helper_t::helper_weak_ptr_t ptr_t;
        static ptr_t helper;
        if (!boost::make_shared(helper).get())
            new helper_t(helper);
        return boost::make_shared(helper)->define(self);
    }
    template <int N>
    struct call_helper {
        template <typename RT, typename DefinitionT, typename ScannerT>
        static void
        do_ (RT &result, DefinitionT &def, ScannerT const &scan)
        {
            result = def.template get_start_parser<N>()->parse(scan);
        }
    };
    template <>
    struct call_helper<0> {
        template <typename RT, typename DefinitionT, typename ScannerT>
        static void
        do_ (RT &result, DefinitionT &def, ScannerT const &scan)
        {
            result = def.start().parse(scan);
        }
    };
    template<int N, typename DerivedT, typename ContextT, typename ScannerT>
    inline typename parser_result<grammar<DerivedT, ContextT>, ScannerT>::type
    grammar_parser_parse(
        grammar<DerivedT, ContextT> const* self,
        ScannerT const &scan)
    {
        typedef
            typename parser_result<grammar<DerivedT, ContextT>, ScannerT>::type
            result_t;
        typedef typename DerivedT::template definition<ScannerT> definition_t;
        result_t result;
        definition_t &def = get_definition<DerivedT, ContextT, ScannerT>(self);
        call_helper<N>::do_(result, def, scan);
        return result;
    }
    template<typename GrammarT>
    inline void
    grammar_destruct(GrammarT* self)
    {
        typedef impl::grammar_helper_base<GrammarT> helper_base_t;
        typedef grammar_helper_list<GrammarT> helper_list_t;
        typedef typename helper_list_t::vector_t::reverse_iterator iterator_t;
        helper_list_t& helpers =
            grammartract_helper_list::do_(self);
        std::for_each(helpers.rbegin(), helpers.rend(),
            std::bind2nd(std::mem_fun(&helper_base_t::undefine), self));
    }
    template <typename DerivedT, int N, typename ContextT>
    class entry_grammar
        : public parser<entry_grammar<DerivedT, N, ContextT> >
    {
    public:
        typedef entry_grammar<DerivedT, N, ContextT> self_t;
        typedef DerivedT const& embed_t;
        typedef typename ContextT::context_linker_t context_t;
        typedef typename context_t::attr_t attr_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, attr_t>::type type;
        };
        entry_grammar(DerivedT const &p) : target_grammar(p) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse_main(ScannerT const& scan) const
        { return impl::grammar_parser_parse<N>(&target_grammar, scan); }
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef parser_scanner_linker<ScannerT> scanner_t;
            scanner_t scan_wrap(scan); context_t context_wrap(*this); context_wrap.pre_parse(*this, scan_wrap); result_t hit = parse_main(scan); return context_wrap.post_parse(hit, *this, scan_wrap);
        }
    private:
        DerivedT const &target_grammar;
    };
    }
}}
namespace boost { namespace spirit {
template <typename DerivedT, typename ContextT = parser_context<> >
struct grammar
    : public parser<DerivedT>
    , public ContextT::base_t
    , public context_aux<ContextT, DerivedT>
    , public impl::object_with_id<impl::grammar_tag>
{
    typedef grammar<DerivedT, ContextT> self_t;
    typedef DerivedT const& embed_t;
    typedef typename ContextT::context_linker_t context_t;
    typedef typename context_t::attr_t attr_t;
    template <typename ScannerT>
    struct result
    {
        typedef typename match_result<ScannerT, attr_t>::type type;
    };
    grammar() {}
    ~grammar() { impl::grammar_destruct(this); }
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse_main(ScannerT const& scan) const
    { return impl::grammar_parser_parse<0>(this, scan); }
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        typedef typename parser_result<self_t, ScannerT>::type result_t;
        typedef parser_scanner_linker<ScannerT> scanner_t;
        scanner_t scan_wrap(scan); context_t context_wrap(*this); context_wrap.pre_parse(*this, scan_wrap); result_t hit = parse_main(scan); return context_wrap.post_parse(hit, *this, scan_wrap);
    }
    template <int N>
    impl::entry_grammar<DerivedT, N, ContextT>
    use_parser() const
    { return impl::entry_grammar<DerivedT, N, ContextT>( this->derived()); }
    private: friend struct impl::grammartract_helper_list; mutable impl::grammar_helper_list<self_t> helpers;
};
}}
namespace boost { namespace spirit {
    template <typename ParserT, typename ActionT>
    class action : public unary<ParserT, parser<action<ParserT, ActionT> > >
    {
    public:
        typedef action<ParserT, ActionT> self_t;
        typedef action_parser_category parser_category_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        typedef ActionT predicate_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<ParserT, ScannerT>::type type;
        };
        action(ParserT const& p, ActionT const& a)
        : base_t(p)
        , actor(a) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename ScannerT::iterator_t iterator_t;
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            scan.at_end();
            iterator_t save = scan.first;
            result_t hit = this->subject().parse(scan);
            if (hit)
            {
                typename result_t::return_t val = hit.value();
                scan.do_action(actor, val, save, scan.first);
            }
            return hit;
        }
        ActionT const& predicate() const { return actor; }
    private:
        ActionT actor;
    };
}}
namespace boost { namespace spirit {
    namespace impl
    {
        template<typename T>
        struct default_as_parser
        {
            typedef T type;
            static type const& convert(type const& p)
            {
                return p;
            }
        };
        struct char_as_parser
        {
            typedef chlit<char> type;
            static type convert(char ch)
            {
                return type(ch);
            }
        };
        struct wchar_as_parser
        {
            typedef chlit<wchar_t> type;
            static type convert(wchar_t ch)
            {
                return type(ch);
            }
        };
        struct string_as_parser
        {
            typedef strlit<char const*> type;
            static type convert(char const* str)
            {
                return type(str);
            }
        };
        struct wstring_as_parser
        {
            typedef strlit<wchar_t const*> type;
            static type convert(wchar_t const* str)
            {
                return type(str);
            }
        };
    }
    template<typename T>
    struct as_parser : impl::default_as_parser<T> {};
    template<>
    struct as_parser<char> : impl::char_as_parser {};
    template<>
    struct as_parser<wchar_t> : impl::wchar_as_parser {};
    template<>
    struct as_parser<char*> : impl::string_as_parser {};
    template<>
    struct as_parser<char const*> : impl::string_as_parser {};
    template<>
    struct as_parser<wchar_t*> : impl::wstring_as_parser {};
    template<>
    struct as_parser<wchar_t const*> : impl::wstring_as_parser {};
    template<int N>
    struct as_parser<char[N]> : impl::string_as_parser {};
    template<int N>
    struct as_parser<wchar_t[N]> : impl::wstring_as_parser {};
    template<int N>
    struct as_parser<char const[N]> : impl::string_as_parser {};
    template<int N>
    struct as_parser<wchar_t const[N]> : impl::wstring_as_parser {};
}}
namespace boost { namespace spirit {
    struct sequence_parser_gen;
    template <typename A, typename B>
    struct sequence : public binary<A, B, parser<sequence<A, B> > >
    {
        typedef sequence<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef sequence_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        sequence(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            if (result_t ma = this->left().parse(scan))
                if (result_t mb = this->right().parse(scan))
                {
                    scan.concat_match(ma, mb);
                    return ma;
                }
            return scan.no_match();
        }
    };
    struct sequence_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                sequence<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static sequence<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return sequence<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    sequence<A, B>
    operator>>(parser<A> const& a, parser<B> const& b);
    template <typename A>
    sequence<A, chlit<char> >
    operator>>(parser<A> const& a, char b);
    template <typename B>
    sequence<chlit<char>, B>
    operator>>(char a, parser<B> const& b);
    template <typename A>
    sequence<A, strlit<char const*> >
    operator>>(parser<A> const& a, char const* b);
    template <typename B>
    sequence<strlit<char const*>, B>
    operator>>(char const* a, parser<B> const& b);
    template <typename A>
    sequence<A, chlit<wchar_t> >
    operator>>(parser<A> const& a, wchar_t b);
    template <typename B>
    sequence<chlit<wchar_t>, B>
    operator>>(wchar_t a, parser<B> const& b);
    template <typename A>
    sequence<A, strlit<wchar_t const*> >
    operator>>(parser<A> const& a, wchar_t const* b);
    template <typename B>
    sequence<strlit<wchar_t const*>, B>
    operator>>(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline sequence<A, B>
    operator>>(parser<A> const& a, parser<B> const& b)
    {
        return sequence<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline sequence<A, chlit<char> >
    operator>>(parser<A> const& a, char b)
    {
        return sequence<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<chlit<char>, B>
    operator>>(char a, parser<B> const& b)
    {
        return sequence<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, strlit<char const*> >
    operator>>(parser<A> const& a, char const* b)
    {
        return sequence<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<strlit<char const*>, B>
    operator>>(char const* a, parser<B> const& b)
    {
        return sequence<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, chlit<wchar_t> >
    operator>>(parser<A> const& a, wchar_t b)
    {
        return sequence<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<chlit<wchar_t>, B>
    operator>>(wchar_t a, parser<B> const& b)
    {
        return sequence<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, strlit<wchar_t const*> >
    operator>>(parser<A> const& a, wchar_t const* b)
    {
        return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<strlit<wchar_t const*>, B>
    operator>>(wchar_t const* a, parser<B> const& b)
    {
        return sequence<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    sequence<A, B>
    operator&&(parser<A> const& a, parser<B> const& b);
    template <typename A>
    sequence<A, chlit<char> >
    operator&&(parser<A> const& a, char b);
    template <typename B>
    sequence<chlit<char>, B>
    operator&&(char a, parser<B> const& b);
    template <typename A>
    sequence<A, strlit<char const*> >
    operator&&(parser<A> const& a, char const* b);
    template <typename B>
    sequence<strlit<char const*>, B>
    operator&&(char const* a, parser<B> const& b);
    template <typename A>
    sequence<A, chlit<wchar_t> >
    operator&&(parser<A> const& a, wchar_t b);
    template <typename B>
    sequence<chlit<wchar_t>, B>
    operator&&(wchar_t a, parser<B> const& b);
    template <typename A>
    sequence<A, strlit<wchar_t const*> >
    operator&&(parser<A> const& a, wchar_t const* b);
    template <typename B>
    sequence<strlit<wchar_t const*>, B>
    operator&&(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline sequence<A, B>
    operator&&(parser<A> const& a, parser<B> const& b)
    {
        return sequence<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline sequence<A, chlit<char> >
    operator&&(parser<A> const& a, char b)
    {
        return sequence<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<chlit<char>, B>
    operator&&(char a, parser<B> const& b)
    {
        return sequence<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, strlit<char const*> >
    operator&&(parser<A> const& a, char const* b)
    {
        return sequence<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<strlit<char const*>, B>
    operator&&(char const* a, parser<B> const& b)
    {
        return sequence<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, chlit<wchar_t> >
    operator&&(parser<A> const& a, wchar_t b)
    {
        return sequence<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<chlit<wchar_t>, B>
    operator&&(wchar_t a, parser<B> const& b)
    {
        return sequence<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline sequence<A, strlit<wchar_t const*> >
    operator&&(parser<A> const& a, wchar_t const* b)
    {
        return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequence<strlit<wchar_t const*>, B>
    operator&&(wchar_t const* a, parser<B> const& b)
    {
        return sequence<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct sequential_or_parser_gen;
    template <typename A, typename B>
    struct sequential_or : public binary<A, B, parser<sequential_or<A, B> > >
    {
        typedef sequential_or<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef sequential_or_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        sequential_or(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            {
                iterator_t save = scan.first;
                if (result_t ma = this->left().parse(scan))
                {
                    save = scan.first;
                    if (result_t mb = this->right().parse(scan))
                    {
                        scan.concat_match(ma, mb);
                        return ma;
                    }
                    else
                    {
                        scan.first = save;
                        return ma;
                    }
                }
                scan.first = save;
            }
            return this->right().parse(scan);
        }
    };
    struct sequential_or_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                sequential_or<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static sequential_or<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return sequential_or<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    sequential_or<A, B>
    operator||(parser<A> const& a, parser<B> const& b);
    template <typename A>
    sequential_or<A, chlit<char> >
    operator||(parser<A> const& a, char b);
    template <typename B>
    sequential_or<chlit<char>, B>
    operator||(char a, parser<B> const& b);
    template <typename A>
    sequential_or<A, strlit<char const*> >
    operator||(parser<A> const& a, char const* b);
    template <typename B>
    sequential_or<strlit<char const*>, B>
    operator||(char const* a, parser<B> const& b);
    template <typename A>
    sequential_or<A, chlit<wchar_t> >
    operator||(parser<A> const& a, wchar_t b);
    template <typename B>
    sequential_or<chlit<wchar_t>, B>
    operator||(wchar_t a, parser<B> const& b);
    template <typename A>
    sequential_or<A, strlit<wchar_t const*> >
    operator||(parser<A> const& a, wchar_t const* b);
    template <typename B>
    sequential_or<strlit<wchar_t const*>, B>
    operator||(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline sequential_or<A, B>
    operator||(parser<A> const& a, parser<B> const& b)
    {
        return sequential_or<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline sequential_or<A, chlit<char> >
    operator||(parser<A> const& a, char b)
    {
        return sequential_or<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline sequential_or<chlit<char>, B>
    operator||(char a, parser<B> const& b)
    {
        return sequential_or<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline sequential_or<A, strlit<char const*> >
    operator||(parser<A> const& a, char const* b)
    {
        return sequential_or<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequential_or<strlit<char const*>, B>
    operator||(char const* a, parser<B> const& b)
    {
        return sequential_or<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline sequential_or<A, chlit<wchar_t> >
    operator||(parser<A> const& a, wchar_t b)
    {
        return sequential_or<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline sequential_or<chlit<wchar_t>, B>
    operator||(wchar_t a, parser<B> const& b)
    {
        return sequential_or<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline sequential_or<A, strlit<wchar_t const*> >
    operator||(parser<A> const& a, wchar_t const* b)
    {
        return sequential_or<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline sequential_or<strlit<wchar_t const*>, B>
    operator||(wchar_t const* a, parser<B> const& b)
    {
        return sequential_or<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct alternative_parser_gen;
    template <typename A, typename B>
    struct alternative
    : public binary<A, B, parser<alternative<A, B> > >
    {
        typedef alternative<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef alternative_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        alternative(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            {
                iterator_t save = scan.first;
                if (result_t hit = this->left().parse(scan))
                    return hit;
                scan.first = save;
            }
            return this->right().parse(scan);
        }
    };
    struct alternative_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                alternative<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static alternative<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return alternative<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    alternative<A, B>
    operator|(parser<A> const& a, parser<B> const& b);
    template <typename A>
    alternative<A, chlit<char> >
    operator|(parser<A> const& a, char b);
    template <typename B>
    alternative<chlit<char>, B>
    operator|(char a, parser<B> const& b);
    template <typename A>
    alternative<A, strlit<char const*> >
    operator|(parser<A> const& a, char const* b);
    template <typename B>
    alternative<strlit<char const*>, B>
    operator|(char const* a, parser<B> const& b);
    template <typename A>
    alternative<A, chlit<wchar_t> >
    operator|(parser<A> const& a, wchar_t b);
    template <typename B>
    alternative<chlit<wchar_t>, B>
    operator|(wchar_t a, parser<B> const& b);
    template <typename A>
    alternative<A, strlit<wchar_t const*> >
    operator|(parser<A> const& a, wchar_t const* b);
    template <typename B>
    alternative<strlit<wchar_t const*>, B>
    operator|(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline alternative<A, B>
    operator|(parser<A> const& a, parser<B> const& b)
    {
        return alternative<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline alternative<A, chlit<char> >
    operator|(parser<A> const& a, char b)
    {
        return alternative<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline alternative<chlit<char>, B>
    operator|(char a, parser<B> const& b)
    {
        return alternative<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline alternative<A, strlit<char const*> >
    operator|(parser<A> const& a, char const* b)
    {
        return alternative<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline alternative<strlit<char const*>, B>
    operator|(char const* a, parser<B> const& b)
    {
        return alternative<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline alternative<A, chlit<wchar_t> >
    operator|(parser<A> const& a, wchar_t b)
    {
        return alternative<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline alternative<chlit<wchar_t>, B>
    operator|(wchar_t a, parser<B> const& b)
    {
        return alternative<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline alternative<A, strlit<wchar_t const*> >
    operator|(parser<A> const& a, wchar_t const* b)
    {
        return alternative<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline alternative<strlit<wchar_t const*>, B>
    operator|(wchar_t const* a, parser<B> const& b)
    {
        return alternative<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct difference_parser_gen;
    template <typename A, typename B>
    struct difference
    : public binary<A, B, parser<difference<A, B> > >
    {
        typedef difference<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef difference_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        difference(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t save = scan.first;
            if (result_t hl = this->left().parse(scan))
            {
                std::swap(save, scan.first);
                result_t hr = this->right().parse(scan);
                if (!hr || (hr.length() < hl.length()))
                {
                    scan.first = save;
                    return hl;
                }
            }
            return scan.no_match();
        }
    };
    struct difference_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                difference<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static difference<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return difference<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    difference<A, B>
    operator-(parser<A> const& a, parser<B> const& b);
    template <typename A>
    difference<A, chlit<char> >
    operator-(parser<A> const& a, char b);
    template <typename B>
    difference<chlit<char>, B>
    operator-(char a, parser<B> const& b);
    template <typename A>
    difference<A, strlit<char const*> >
    operator-(parser<A> const& a, char const* b);
    template <typename B>
    difference<strlit<char const*>, B>
    operator-(char const* a, parser<B> const& b);
    template <typename A>
    difference<A, chlit<wchar_t> >
    operator-(parser<A> const& a, wchar_t b);
    template <typename B>
    difference<chlit<wchar_t>, B>
    operator-(wchar_t a, parser<B> const& b);
    template <typename A>
    difference<A, strlit<wchar_t const*> >
    operator-(parser<A> const& a, wchar_t const* b);
    template <typename B>
    difference<strlit<wchar_t const*>, B>
    operator-(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline difference<A, B>
    operator-(parser<A> const& a, parser<B> const& b)
    {
        return difference<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline difference<A, chlit<char> >
    operator-(parser<A> const& a, char b)
    {
        return difference<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline difference<chlit<char>, B>
    operator-(char a, parser<B> const& b)
    {
        return difference<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline difference<A, strlit<char const*> >
    operator-(parser<A> const& a, char const* b)
    {
        return difference<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline difference<strlit<char const*>, B>
    operator-(char const* a, parser<B> const& b)
    {
        return difference<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline difference<A, chlit<wchar_t> >
    operator-(parser<A> const& a, wchar_t b)
    {
        return difference<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline difference<chlit<wchar_t>, B>
    operator-(wchar_t a, parser<B> const& b)
    {
        return difference<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline difference<A, strlit<wchar_t const*> >
    operator-(parser<A> const& a, wchar_t const* b)
    {
        return difference<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline difference<strlit<wchar_t const*>, B>
    operator-(wchar_t const* a, parser<B> const& b)
    {
        return difference<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct intersection_parser_gen;
    template <typename A, typename B>
    struct intersection
    : public binary<A, B, parser<intersection<A, B> > >
    {
        typedef intersection<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef intersection_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        intersection(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t save = scan.first;
            if (result_t hl = this->left().parse(scan))
            {
                ScannerT bscan(scan.first, scan.first);
                scan.first = save;
                result_t hr = this->right().parse(bscan);
                if (hl.length() == hr.length())
                    return hl;
            }
            return scan.no_match();
        }
    };
    struct intersection_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                intersection<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static intersection<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return intersection<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    intersection<A, B>
    operator&(parser<A> const& a, parser<B> const& b);
    template <typename A>
    intersection<A, chlit<char> >
    operator&(parser<A> const& a, char b);
    template <typename B>
    intersection<chlit<char>, B>
    operator&(char a, parser<B> const& b);
    template <typename A>
    intersection<A, strlit<char const*> >
    operator&(parser<A> const& a, char const* b);
    template <typename B>
    intersection<strlit<char const*>, B>
    operator&(char const* a, parser<B> const& b);
    template <typename A>
    intersection<A, chlit<wchar_t> >
    operator&(parser<A> const& a, wchar_t b);
    template <typename B>
    intersection<chlit<wchar_t>, B>
    operator&(wchar_t a, parser<B> const& b);
    template <typename A>
    intersection<A, strlit<wchar_t const*> >
    operator&(parser<A> const& a, wchar_t const* b);
    template <typename B>
    intersection<strlit<wchar_t const*>, B>
    operator&(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline intersection<A, B>
    operator&(parser<A> const& a, parser<B> const& b)
    {
        return intersection<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline intersection<A, chlit<char> >
    operator&(parser<A> const& a, char b)
    {
        return intersection<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline intersection<chlit<char>, B>
    operator&(char a, parser<B> const& b)
    {
        return intersection<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline intersection<A, strlit<char const*> >
    operator&(parser<A> const& a, char const* b)
    {
        return intersection<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline intersection<strlit<char const*>, B>
    operator&(char const* a, parser<B> const& b)
    {
        return intersection<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline intersection<A, chlit<wchar_t> >
    operator&(parser<A> const& a, wchar_t b)
    {
        return intersection<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline intersection<chlit<wchar_t>, B>
    operator&(wchar_t a, parser<B> const& b)
    {
        return intersection<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline intersection<A, strlit<wchar_t const*> >
    operator&(parser<A> const& a, wchar_t const* b)
    {
        return intersection<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline intersection<strlit<wchar_t const*>, B>
    operator&(wchar_t const* a, parser<B> const& b)
    {
        return intersection<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct exclusive_or_parser_gen;
    template <typename A, typename B>
    struct exclusive_or
    : public binary<A, B, parser<exclusive_or<A, B> > >
    {
        typedef exclusive_or<A, B> self_t;
        typedef binary_parser_category parser_category_t;
        typedef exclusive_or_parser_gen parser_generator_t;
        typedef binary<A, B, parser<self_t> > base_t;
        exclusive_or(A const& a, B const& b)
        : base_t(a, b) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t save = scan.first;
            result_t l = this->left().parse(scan);
            std::swap(save, scan.first);
            result_t r = this->right().parse(scan);
            if (l ? !bool(r) : bool(r))
            {
                if (l)
                    scan.first = save;
                return l ? l : r;
            }
            return scan.no_match();
        }
    };
    struct exclusive_or_parser_gen
    {
        template <typename A, typename B>
        struct result
        {
            typedef
                exclusive_or<
                    typename as_parser<A>::type
                  , typename as_parser<B>::type
                >
            type;
        };
        template <typename A, typename B>
        static exclusive_or<
            typename as_parser<A>::type
          , typename as_parser<B>::type
        >
        generate(A const& a, B const& b)
        {
            return exclusive_or<typename as_parser<A>::type,
                typename as_parser<B>::type>
                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
        }
    };
    template <typename A, typename B>
    exclusive_or<A, B>
    operator^(parser<A> const& a, parser<B> const& b);
    template <typename A>
    exclusive_or<A, chlit<char> >
    operator^(parser<A> const& a, char b);
    template <typename B>
    exclusive_or<chlit<char>, B>
    operator^(char a, parser<B> const& b);
    template <typename A>
    exclusive_or<A, strlit<char const*> >
    operator^(parser<A> const& a, char const* b);
    template <typename B>
    exclusive_or<strlit<char const*>, B>
    operator^(char const* a, parser<B> const& b);
    template <typename A>
    exclusive_or<A, chlit<wchar_t> >
    operator^(parser<A> const& a, wchar_t b);
    template <typename B>
    exclusive_or<chlit<wchar_t>, B>
    operator^(wchar_t a, parser<B> const& b);
    template <typename A>
    exclusive_or<A, strlit<wchar_t const*> >
    operator^(parser<A> const& a, wchar_t const* b);
    template <typename B>
    exclusive_or<strlit<wchar_t const*>, B>
    operator^(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline exclusive_or<A, B>
    operator^(parser<A> const& a, parser<B> const& b)
    {
        return exclusive_or<A, B>(a.derived(), b.derived());
    }
    template <typename A>
    inline exclusive_or<A, chlit<char> >
    operator^(parser<A> const& a, char b)
    {
        return exclusive_or<A, chlit<char> >(a.derived(), b);
    }
    template <typename B>
    inline exclusive_or<chlit<char>, B>
    operator^(char a, parser<B> const& b)
    {
        return exclusive_or<chlit<char>, B>(a, b.derived());
    }
    template <typename A>
    inline exclusive_or<A, strlit<char const*> >
    operator^(parser<A> const& a, char const* b)
    {
        return exclusive_or<A, strlit<char const*> >(a.derived(), b);
    }
    template <typename B>
    inline exclusive_or<strlit<char const*>, B>
    operator^(char const* a, parser<B> const& b)
    {
        return exclusive_or<strlit<char const*>, B>(a, b.derived());
    }
    template <typename A>
    inline exclusive_or<A, chlit<wchar_t> >
    operator^(parser<A> const& a, wchar_t b)
    {
        return exclusive_or<A, chlit<wchar_t> >(a.derived(), b);
    }
    template <typename B>
    inline exclusive_or<chlit<wchar_t>, B>
    operator^(wchar_t a, parser<B> const& b)
    {
        return exclusive_or<chlit<wchar_t>, B>(a, b.derived());
    }
    template <typename A>
    inline exclusive_or<A, strlit<wchar_t const*> >
    operator^(parser<A> const& a, wchar_t const* b)
    {
        return exclusive_or<A, strlit<wchar_t const*> >(a.derived(), b);
    }
    template <typename B>
    inline exclusive_or<strlit<wchar_t const*>, B>
    operator^(wchar_t const* a, parser<B> const& b)
    {
        return exclusive_or<strlit<wchar_t const*>, B>(a, b.derived());
    }
}}
namespace boost { namespace spirit {
    struct kleene_star_parser_gen;
    template <typename S>
    struct kleene_star
    : public unary<S, parser<kleene_star<S> > >
    {
        typedef kleene_star<S> self_t;
        typedef unary_parser_category parser_category_t;
        typedef kleene_star_parser_gen parser_generator_t;
        typedef unary<S, parser<self_t> > base_t;
        kleene_star(S const& a)
        : base_t(a) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            result_t hit = scan.empty_match();
            for (;;)
            {
                iterator_t save = scan.first;
                if (result_t next = this->subject().parse(scan))
                {
                    scan.concat_match(hit, next);
                }
                else
                {
                    scan.first = save;
                    return hit;
                }
            }
        }
    };
    struct kleene_star_parser_gen
    {
        template <typename S>
        struct result
        {
            typedef kleene_star<S> type;
        };
        template <typename S>
        static kleene_star<S>
        generate(parser<S> const& a)
        {
            return kleene_star<S>(a.derived());
        }
    };
    template <typename S>
    kleene_star<S>
    operator*(parser<S> const& a);
}}
namespace boost { namespace spirit {
    template <typename S>
    inline kleene_star<S>
    operator*(parser<S> const& a)
    {
        return kleene_star<S>(a.derived());
    }
}}
namespace boost { namespace spirit {
    struct positive_parser_gen;
    template <typename S>
    struct positive
    : public unary<S, parser<positive<S> > >
    {
        typedef positive<S> self_t;
        typedef unary_parser_category parser_category_t;
        typedef positive_parser_gen parser_generator_t;
        typedef unary<S, parser<self_t> > base_t;
        positive(S const& a)
        : base_t(a) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            result_t hit = this->subject().parse(scan);
            if (hit)
            {
                for (;;)
                {
                    iterator_t save = scan.first;
                    if (result_t next = this->subject().parse(scan))
                    {
                        scan.concat_match(hit, next);
                    }
                    else
                    {
                        scan.first = save;
                        break;
                    }
                }
            }
            return hit;
        }
    };
    struct positive_parser_gen
    {
        template <typename S>
        struct result
        {
            typedef positive<S> type;
        };
        template <typename S>
        static positive<S>
        generate(parser<S> const& a)
        {
            return positive<S>(a.derived());
        }
    };
    template <typename S>
    inline positive<S>
    operator+(parser<S> const& a);
}}
namespace boost { namespace spirit {
    template <typename S>
    inline positive<S>
    operator+(parser<S> const& a)
    {
        return positive<S>(a.derived());
    }
}}
namespace boost { namespace spirit {
    struct optional_parser_gen;
    template <typename S>
    struct optional
    : public unary<S, parser<optional<S> > >
    {
        typedef optional<S> self_t;
        typedef unary_parser_category parser_category_t;
        typedef optional_parser_gen parser_generator_t;
        typedef unary<S, parser<self_t> > base_t;
        optional(S const& a)
        : base_t(a) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t save = scan.first;
            if (result_t r = this->subject().parse(scan))
            {
                return r;
            }
            else
            {
                scan.first = save;
                return scan.empty_match();
            }
        }
    };
    struct optional_parser_gen
    {
        template <typename S>
        struct result
        {
            typedef optional<S> type;
        };
        template <typename S>
        static optional<S>
        generate(parser<S> const& a)
        {
            return optional<S>(a.derived());
        }
    };
    template <typename S>
    optional<S>
    operator!(parser<S> const& a);
}}
namespace boost { namespace spirit {
    template <typename S>
    optional<S>
    operator!(parser<S> const& a)
    {
        return optional<S>(a.derived());
    }
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    sequence<A, kleene_star<sequence<B, A> > >
    operator%(parser<A> const& a, parser<B> const& b);
    template <typename A>
    sequence<A, kleene_star<sequence<chlit<char>, A> > >
    operator%(parser<A> const& a, char b);
    template <typename B>
    sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
    operator%(char a, parser<B> const& b);
    template <typename A>
    sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
    operator%(parser<A> const& a, char const* b);
    template <typename B>
    sequence<strlit<char const*>,
        kleene_star<sequence<B, strlit<char const*> > > >
    operator%(char const* a, parser<B> const& b);
    template <typename A>
    sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
    operator%(parser<A> const& a, wchar_t b);
    template <typename B>
    sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
    operator%(wchar_t a, parser<B> const& b);
    template <typename A>
    sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
    operator%(parser<A> const& a, wchar_t const* b);
    template <typename B>
    sequence<strlit<wchar_t const*>,
        kleene_star<sequence<B, strlit<wchar_t const*> > > >
    operator%(wchar_t const* a, parser<B> const& b);
}}
namespace boost { namespace spirit {
    template <typename A, typename B>
    inline sequence<A, kleene_star<sequence<B, A> > >
    operator%(parser<A> const& a, parser<B> const& b)
    {
        return a.derived() >> *(b.derived() >> a.derived());
    }
    template <typename A>
    inline sequence<A, kleene_star<sequence<chlit<char>, A> > >
    operator%(parser<A> const& a, char b)
    {
        return a.derived() >> *(b >> a.derived());
    }
    template <typename B>
    inline sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
    operator%(char a, parser<B> const& b)
    {
        return a >> *(b.derived() >> a);
    }
    template <typename A>
    inline sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
    operator%(parser<A> const& a, char const* b)
    {
        return a.derived() >> *(b >> a.derived());
    }
    template <typename B>
    inline sequence<strlit<char const*>,
        kleene_star<sequence<B, strlit<char const*> > > >
    operator%(char const* a, parser<B> const& b)
    {
        return a >> *(b.derived() >> a);
    }
    template <typename A>
    inline sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
    operator%(parser<A> const& a, wchar_t b)
    {
        return a.derived() >> *(b >> a.derived());
    }
    template <typename B>
    inline sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
    operator%(wchar_t a, parser<B> const& b)
    {
        return a >> *(b.derived() >> a);
    }
    template <typename A>
    inline sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
    operator%(parser<A> const& a, wchar_t const* b)
    {
        return a.derived() >> *(b >> a.derived());
    }
    template <typename B>
    inline sequence<strlit<wchar_t const*>,
        kleene_star<sequence<B, strlit<wchar_t const*> > > >
    operator%(wchar_t const* a, parser<B> const& b)
    {
        return a >> *(b.derived() >> a);
    }
}}
namespace boost { namespace spirit {
namespace impl
{
    struct parser_type_traits_base {
        static const bool is_alternative = false;
        static const bool is_sequence = false;
        static const bool is_sequential_or = false;
        static const bool is_intersection = false;
        static const bool is_difference = false;
        static const bool is_exclusive_or = false;
        static const bool is_optional = false;
        static const bool is_kleene_star = false;
        static const bool is_positive = false;
    };
    template <typename ParserT>
    struct parser_type_traits : public parser_type_traits_base {
    };
    template <typename A, typename B>
    struct parser_type_traits<alternative<A, B> >
    : public parser_type_traits_base {
        static const bool is_alternative = true;
    };
    template <typename A, typename B>
    struct parser_type_traits<sequence<A, B> >
    : public parser_type_traits_base {
        static const bool is_sequence = true;
    };
    template <typename A, typename B>
    struct parser_type_traits<sequential_or<A, B> >
    : public parser_type_traits_base {
        static const bool is_sequential_or = true;
    };
    template <typename A, typename B>
    struct parser_type_traits<intersection<A, B> >
    : public parser_type_traits_base {
        static const bool is_intersection = true;
    };
    template <typename A, typename B>
    struct parser_type_traits<difference<A, B> >
    : public parser_type_traits_base {
        static const bool is_difference = true;
    };
    template <typename A, typename B>
    struct parser_type_traits<exclusive_or<A, B> >
    : public parser_type_traits_base {
        static const bool is_exclusive_or = true;
    };
    template <typename S>
    struct parser_type_traits<optional<S> >
    : public parser_type_traits_base {
        static const bool is_optional = true;
    };
    template <typename S>
    struct parser_type_traits<kleene_star<S> >
    : public parser_type_traits_base {
        static const bool is_kleene_star = true;
    };
    template <typename S>
    struct parser_type_traits<positive<S> >
    : public parser_type_traits_base {
        static const bool is_positive = true;
    };
}
}}
namespace boost { namespace spirit {
template <typename T>
struct is_parser
{
    static const bool value = (::boost::is_base_and_derived<parser<T>, T>::value);
};
template <typename UnaryT>
struct is_unary_composite {
    static const bool value = (::boost::is_convertible< typename UnaryT::parser_category_t, unary_parser_category>::value);
};
template <typename ActionT>
struct is_action_parser {
    static const bool value = (::boost::is_convertible< typename ActionT::parser_category_t, action_parser_category>::value);
};
template <typename BinaryT>
struct is_binary_composite {
    static const bool value = (::boost::is_convertible< typename BinaryT::parser_category_t, binary_parser_category>::value);
};
template <typename CompositeT>
struct is_composite_parser {
    static const bool value = ( ::boost::spirit::is_unary_composite<CompositeT>::value || ::boost::spirit::is_binary_composite<CompositeT>::value);
};
template <typename ParserT>
struct is_alternative {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_alternative);
};
template <typename ParserT>
struct is_sequence {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_sequence);
};
template <typename ParserT>
struct is_sequential_or {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_sequential_or);
};
template <typename ParserT>
struct is_intersection {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_intersection);
};
template <typename ParserT>
struct is_difference {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_difference);
};
template <typename ParserT>
struct is_exclusive_or {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_exclusive_or);
};
template <typename ParserT>
struct is_optional {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_optional);
};
template <typename ParserT>
struct is_kleene_star {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_kleene_star);
};
template <typename ParserT>
struct is_positive {
    static const bool value = ( ::boost::spirit::impl::parser_type_traits<ParserT>::is_positive);
};
template <typename UnaryT>
struct unary_subject {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_unary_composite<UnaryT>::value ) >)> boost_static_assert_typedef_183;
    typedef typename UnaryT::subject_t type;
};
template <typename UnaryT>
inline typename unary_subject<UnaryT>::type const &
get_unary_subject(UnaryT const &unary_)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_unary_composite<UnaryT>::value ) >)> boost_static_assert_typedef_199;
    return unary_.subject();
}
template <typename BinaryT>
struct binary_left_subject {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_binary_composite<BinaryT>::value ) >)> boost_static_assert_typedef_215;
    typedef typename BinaryT::left_t type;
};
template <typename BinaryT>
struct binary_right_subject {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_binary_composite<BinaryT>::value ) >)> boost_static_assert_typedef_222;
    typedef typename BinaryT::right_t type;
};
template <typename BinaryT>
inline typename binary_left_subject<BinaryT>::type const &
get_binary_left_subject(BinaryT const &binary_)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_binary_composite<BinaryT>::value ) >)> boost_static_assert_typedef_239;
    return binary_.left();
}
template <typename BinaryT>
inline typename binary_right_subject<BinaryT>::type const &
get_binary_right_subject(BinaryT const &binary_)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_binary_composite<BinaryT>::value ) >)> boost_static_assert_typedef_247;
    return binary_.right();
}
template <typename ActionT>
struct action_subject {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_action_parser<ActionT>::value ) >)> boost_static_assert_typedef_262;
    typedef typename ActionT::subject_t type;
};
template <typename ActionT>
inline typename action_subject<ActionT>::type const &
get_action_subject(ActionT const &action_)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_action_parser<ActionT>::value ) >)> boost_static_assert_typedef_278;
    return action_.subject();
}
template <typename ActionT>
struct semantic_action {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_action_parser<ActionT>::value ) >)> boost_static_assert_typedef_293;
    typedef typename ActionT::predicate_t type;
};
template <typename ActionT>
inline typename semantic_action<ActionT>::type const &
get_semantic_action(ActionT const &action_)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ::boost::spirit::is_action_parser<ActionT>::value ) >)> boost_static_assert_typedef_309;
    return action_.predicate();
}
}}
namespace boost {
namespace spirit {
template<typename BaseT = action_policy>
struct no_actions_action_policy:
    public BaseT
{
    typedef BaseT base_t;
    no_actions_action_policy():
        BaseT()
    {}
    template<typename PolicyT>
    no_actions_action_policy(PolicyT const& other):
        BaseT(other)
    {}
    template<typename ActorT, typename AttrT, typename IteratorT>
    void
    do_action(
        ActorT const& actor,
        AttrT& val,
        IteratorT const& first,
        IteratorT const& last) const
    {}
};
template<typename ScannerT = scanner<> >
struct no_actions_scanner
{
    typedef scanner_policies<
        typename ScannerT::iteration_policy_t,
        typename ScannerT::match_policy_t,
        no_actions_action_policy<typename ScannerT::action_policy_t>
    > policies_t;
    typedef typename
        rebind_scanner_policies<ScannerT, policies_t>::type type;
};
struct no_actions_parser_gen;
template<typename ParserT>
struct no_actions_parser:
    public unary<ParserT, parser<no_actions_parser<ParserT> > >
{
    typedef no_actions_parser<ParserT> self_t;
    typedef unary_parser_category parser_category_t;
    typedef no_actions_parser_gen parser_generator_t;
    typedef unary<ParserT, parser<self_t> > base_t;
    template<typename ScannerT>
    struct result
    {
        typedef typename parser_result<ParserT, ScannerT>::type type;
    };
    no_actions_parser(ParserT const& p)
    : base_t(p)
    {}
    template<typename ScannerT>
    typename result<ScannerT>::type
    parse(ScannerT const& scan) const
    {
        typedef typename no_actions_scanner<ScannerT>::policies_t policies_t;
        return this->subject().parse(scan.change_policies(policies_t(scan)));
    }
};
struct no_actions_parser_gen
{
    template<typename ParserT>
    struct result
    {
        typedef no_actions_parser<ParserT> type;
    };
    template<typename ParserT>
    static no_actions_parser<ParserT>
    generate(parser<ParserT> const& subject)
    {
        return no_actions_parser<ParserT>(subject.derived());
    }
    template<typename ParserT>
    no_actions_parser<ParserT>
    operator[](parser<ParserT> const& subject) const
    {
        return no_actions_parser<ParserT>(subject.derived());
    }
};
const no_actions_parser_gen no_actions_d = no_actions_parser_gen();
}
}
namespace boost { namespace spirit {
    template <typename CondT, bool positive = true>
    struct condition_parser : parser<condition_parser<CondT, positive> >
    {
        typedef condition_parser<CondT, positive> self_t;
        condition_parser(CondT const& cond_) : cond(cond_) {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            if (positive == cond())
                return scan.empty_match();
            else
                return scan.no_match();
        }
        condition_parser<CondT, !positive>
        negate() const
        { return condition_parser<CondT, !positive>(cond); }
    private:
        CondT cond;
    };
    template <typename CondT, bool positive>
    inline condition_parser<CondT, !positive>
    operator~(condition_parser<CondT, positive> const& p)
    { return p.negate(); }
    struct empty_match_parser_gen;
    struct negated_empty_match_parser_gen;
    template <typename SubjectT>
    struct negated_empty_match_parser;
    template<typename SubjectT>
    struct empty_match_parser
    : unary<SubjectT, parser<empty_match_parser<SubjectT> > >
    {
        typedef empty_match_parser<SubjectT> self_t;
        typedef unary<SubjectT, parser<self_t> > base_t;
        typedef unary_parser_category parser_category_t;
        typedef empty_match_parser_gen parser_genererator_t;
        typedef self_t embed_t;
        explicit empty_match_parser(SubjectT const& p) : base_t(p) {}
        template <typename ScannerT>
        struct result
        { typedef typename match_result<ScannerT, nil_t>::type type; };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typename ScannerT::iterator_t save(scan.first);
            typedef typename no_actions_scanner<ScannerT>::policies_t
                policies_t;
            bool matches = this->subject().parse(
                scan.change_policies(policies_t(scan)));
            if (matches)
            {
                scan.first = save;
                return scan.empty_match();
            }
            else
            {
                return scan.no_match();
            }
        }
        negated_empty_match_parser<SubjectT>
        negate() const
        { return negated_empty_match_parser<SubjectT>(this->subject()); }
    };
    template<typename SubjectT>
    struct negated_empty_match_parser
    : public unary<SubjectT, parser<negated_empty_match_parser<SubjectT> > >
    {
        typedef negated_empty_match_parser<SubjectT> self_t;
        typedef unary<SubjectT, parser<self_t> > base_t;
        typedef unary_parser_category parser_category_t;
        typedef negated_empty_match_parser_gen parser_genererator_t;
        explicit negated_empty_match_parser(SubjectT const& p) : base_t(p) {}
        template <typename ScannerT>
        struct result
        { typedef typename match_result<ScannerT, nil_t>::type type; };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typename ScannerT::iterator_t save(scan.first);
            bool matches = this->subject().parse(scan);
            if (!matches)
            {
                scan.first = save;
                return scan.empty_match();
            }
            else
            {
                return scan.no_match();
            }
        }
        empty_match_parser<SubjectT>
        negate() const
        { return empty_match_parser<SubjectT>(this->subject()); }
    };
    struct empty_match_parser_gen
    {
        template <typename SubjectT>
        struct result
        { typedef empty_match_parser<SubjectT> type; };
        template <typename SubjectT>
        static empty_match_parser<SubjectT>
        generate(parser<SubjectT> const& subject)
        { return empty_match_parser<SubjectT>(subject.derived()); }
    };
    struct negated_empty_match_parser_gen
    {
        template <typename SubjectT>
        struct result
        { typedef negated_empty_match_parser<SubjectT> type; };
        template <typename SubjectT>
        static negated_empty_match_parser<SubjectT>
        generate(parser<SubjectT> const& subject)
        { return negated_empty_match_parser<SubjectT>(subject.derived()); }
    };
    template <typename SubjectT>
    inline negated_empty_match_parser<SubjectT>
    operator~(empty_match_parser<SubjectT> const& p)
    { return p.negate(); }
    template <typename SubjectT>
    inline empty_match_parser<SubjectT>
    operator~(negated_empty_match_parser<SubjectT> const& p)
    { return p.negate(); }
    namespace impl
    {
        template <typename SubjectT>
        struct epsilon_selector
        {
            typedef typename as_parser<SubjectT>::type subject_t;
            typedef typename
                mpl::if_<
                    is_parser<subject_t>
                    ,empty_match_parser<subject_t>
                    ,condition_parser<subject_t>
                >::type type;
        };
    }
    struct epsilon_parser : public parser<epsilon_parser>
    {
        typedef epsilon_parser self_t;
        epsilon_parser() {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        { return scan.empty_match(); }
        template <typename SubjectT>
        typename impl::epsilon_selector<SubjectT>::type
        operator()(SubjectT const& subject) const
        {
            typedef typename impl::epsilon_selector<SubjectT>::type result_t;
            return result_t(subject);
        }
    };
    epsilon_parser const epsilon_p = epsilon_parser();
    epsilon_parser const eps_p = epsilon_parser();
}}
#include <bitset>
namespace boost { namespace spirit { namespace utility { namespace impl {
    template <typename CharT>
    struct range {
                        range(CharT first, CharT last);
        bool is_valid() const;
        bool includes(CharT v) const;
        bool includes(range const& r) const;
        bool overlaps(range const& r) const;
        void merge(range const& r);
        CharT first;
        CharT last;
    };
    template <typename CharT>
    struct range_char_compare {
        bool operator()(range<CharT> const& x, const CharT y) const
        { return x.first < y; }
    };
    template <typename CharT>
    struct range_compare {
        bool operator()(range<CharT> const& x, range<CharT> const& y) const
        { return x.first < y.first; }
    };
    template <typename CharT>
    class range_run {
    public:
        typedef range<CharT> range_t;
        typedef std::vector<range_t> run_t;
        typedef typename run_t::iterator iterator;
        typedef typename run_t::const_iterator const_iterator;
        void swap(range_run& rr);
        bool test(CharT v) const;
        void set(range_t const& r);
        void clear(range_t const& r);
        void clear();
        const_iterator begin() const;
        const_iterator end() const;
    private:
        void merge(iterator iter, range_t const& r);
        run_t run;
    };
}}}}
namespace boost { namespace spirit {
    namespace utility { namespace impl {
        template <typename CharT>
        inline range<CharT>::range(CharT first_, CharT last_)
        : first(first_), last(last_) {}
        template <typename CharT>
        inline bool
        range<CharT>::is_valid() const
        { return first <= last; }
        template <typename CharT>
        inline bool
        range<CharT>::includes(range const& r) const
        { return (first <= r.first) && (last >= r.last); }
        template <typename CharT>
        inline bool
        range<CharT>::includes(CharT v) const
        { return (first <= v) && (last >= v); }
        template <typename CharT>
        inline bool
        range<CharT>::overlaps(range const& r) const
        {
            CharT decr_first =
                first == std::numeric_limits<CharT>::min() ? first : first-1;
            CharT incr_last =
                last == std::numeric_limits<CharT>::max() ? last : last+1;
            return (decr_first <= r.last) && (incr_last >= r.first);
        }
        template <typename CharT>
        inline void
        range<CharT>::merge(range const& r)
        {
            first = std::min(first, r.first);
            last = std::max(last, r.last);
        }
        template <typename CharT>
        inline bool
        range_run<CharT>::test(CharT v) const
        {
            if (!run.empty())
            {
                const_iterator iter =
                    std::lower_bound(
                        run.begin(), run.end(), v,
                        range_char_compare<CharT>()
                    );
                if (iter != run.end() && iter->includes(v))
                    return true;
                if (iter != run.begin())
                    return (--iter)->includes(v);
            }
            return false;
        }
        template <typename CharT>
        inline void
        range_run<CharT>::swap(range_run& rr)
        { run.swap(rr.run); }
        template <typename CharT>
        void
        range_run<CharT>::merge(iterator iter, range<CharT> const& r)
        {
            iter->merge(r);
            iterator i = iter + 1;
            while (i != run.end() && iter->overlaps(*i))
                iter->merge(*i++);
            run.erase(iter+1, i);
        }
        template <typename CharT>
        void
        range_run<CharT>::set(range<CharT> const& r)
        {
            ;
            if (!run.empty())
            {
                iterator iter =
                    std::lower_bound(
                        run.begin(), run.end(), r,
                        range_compare<CharT>()
                    );
                if (iter != run.end() && iter->includes(r) ||
                    ((iter != run.begin()) && (iter - 1)->includes(r)))
                    return;
                if (iter != run.begin() && (iter - 1)->overlaps(r))
                    merge(--iter, r);
                else if (iter != run.end() && iter->overlaps(r))
                    merge(iter, r);
                else
                    run.insert(iter, r);
            }
            else
            {
                run.push_back(r);
            }
        }
        template <typename CharT>
        void
        range_run<CharT>::clear(range<CharT> const& r)
        {
            ;
            if (!run.empty())
            {
                iterator iter =
                    std::lower_bound(
                        run.begin(), run.end(), r,
                        range_compare<CharT>()
                    );
                iterator left_iter;
                if ((iter != run.begin()) &&
                        (left_iter = (iter - 1))->includes(r.first))
                    if (left_iter->last > r.last)
                    {
                        CharT save_last = left_iter->last;
                        left_iter->last = r.first-1;
                        run.insert(iter, range<CharT>(r.last+1, save_last));
                        return;
                    }
                    else
                    {
                        left_iter->last = r.first-1;
                    }
                iterator i = iter;
                while (i != run.end() && r.includes(*i))
                    i++;
                if (i != run.end() && i->includes(r.last))
                    i->first = r.last+1;
                run.erase(iter, i);
            }
        }
        template <typename CharT>
        inline void
        range_run<CharT>::clear()
        { run.clear(); }
        template <typename CharT>
        inline typename range_run<CharT>::const_iterator
        range_run<CharT>::begin() const
        { return run.begin(); }
        template <typename CharT>
        inline typename range_run<CharT>::const_iterator
        range_run<CharT>::end() const
        { return run.end(); }
    }}
}}
namespace boost { namespace spirit {
    template <typename CharT>
    class basic_chset
    {
    public:
                            basic_chset();
                            basic_chset(basic_chset const& arg_);
        bool test(CharT v) const;
        void set(CharT from, CharT to);
        void set(CharT c);
        void clear(CharT from, CharT to);
        void clear(CharT c);
        void clear();
        void inverse();
        void swap(basic_chset& x);
        basic_chset& operator|=(basic_chset const& x);
        basic_chset& operator&=(basic_chset const& x);
        basic_chset& operator-=(basic_chset const& x);
        basic_chset& operator^=(basic_chset const& x);
        private: utility::impl::range_run<CharT> rr;
    };
    template <typename CharT>
    class basic_chset_8bit {
    public:
                            basic_chset_8bit();
                            basic_chset_8bit(basic_chset_8bit const& arg_);
        bool test(CharT v) const;
        void set(CharT from, CharT to);
        void set(CharT c);
        void clear(CharT from, CharT to);
        void clear(CharT c);
        void clear();
        void inverse();
        void swap(basic_chset_8bit& x);
        basic_chset_8bit& operator|=(basic_chset_8bit const& x);
        basic_chset_8bit& operator&=(basic_chset_8bit const& x);
        basic_chset_8bit& operator-=(basic_chset_8bit const& x);
        basic_chset_8bit& operator^=(basic_chset_8bit const& x);
        private: std::bitset<256> bset;
    };
    template <>
    class basic_chset<char>
    : public basic_chset_8bit<char> {};
    template <>
    class basic_chset<signed char>
    : public basic_chset_8bit<signed char> {};
    template <>
    class basic_chset<unsigned char>
    : public basic_chset_8bit<unsigned char> {};
}}
namespace boost { namespace spirit {
template <typename CharT>
inline basic_chset<CharT>::basic_chset() {}
template <typename CharT>
inline basic_chset<CharT>::basic_chset(basic_chset const& arg_)
: rr(arg_.rr) {}
template <typename CharT>
inline bool
basic_chset<CharT>::test(CharT v) const
{ return rr.test(v); }
template <typename CharT>
inline void
basic_chset<CharT>::set(CharT from, CharT to)
{ rr.set(utility::impl::range<CharT>(from, to)); }
template <typename CharT>
inline void
basic_chset<CharT>::set(CharT c)
{ rr.set(utility::impl::range<CharT>(c, c)); }
template <typename CharT>
inline void
basic_chset<CharT>::clear(CharT from, CharT to)
{ rr.clear(utility::impl::range<CharT>(from, to)); }
template <typename CharT>
inline void
basic_chset<CharT>::clear()
{ rr.clear(); }
template <typename CharT>
inline void
basic_chset<CharT>::inverse()
{
    basic_chset inv;
    inv.set(
        std::numeric_limits<CharT>::min(),
        std::numeric_limits<CharT>::max()
    );
    inv -= *this;
    swap(inv);
}
template <typename CharT>
inline void
basic_chset<CharT>::swap(basic_chset& x)
{ rr.swap(x.rr); }
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator|=(basic_chset<CharT> const& x)
{
    typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
    for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
        rr.set(*iter);
    return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator&=(basic_chset<CharT> const& x)
{
    basic_chset inv;
    inv.set(
        std::numeric_limits<CharT>::min(),
        std::numeric_limits<CharT>::max()
    );
    inv -= x;
    *this -= inv;
    return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator-=(basic_chset<CharT> const& x)
{
    typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
    for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
        rr.clear(*iter);
    return *this;
}
template <typename CharT>
inline basic_chset<CharT>&
basic_chset<CharT>::operator^=(basic_chset<CharT> const& x)
{
    basic_chset bma = x;
    bma -= *this;
    *this -= x;
    *this |= bma;
    return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>::basic_chset_8bit() {}
template <typename CharT>
inline basic_chset_8bit<CharT>::basic_chset_8bit(basic_chset_8bit const& arg_)
: bset(arg_.bset) {}
template <typename CharT>
inline bool
basic_chset_8bit<CharT>::test(CharT v) const
{ return bset.test((unsigned char)v); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::set(CharT from, CharT to)
{
    for (int i = from; i <= to; ++i)
        bset.set((unsigned char)i);
}
template <typename CharT>
inline void
basic_chset_8bit<CharT>::set(CharT c)
{ bset.set((unsigned char)c); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear(CharT from, CharT to)
{
    for (int i = from; i <= to; ++i)
        bset.reset((unsigned char)i);
}
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear(CharT c)
{ bset.reset((unsigned char)c); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::clear()
{ bset.reset(); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::inverse()
{ bset.flip(); }
template <typename CharT>
inline void
basic_chset_8bit<CharT>::swap(basic_chset_8bit& x)
{ std::swap(bset, x.bset); }
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator|=(basic_chset_8bit const& x)
{
    bset |= x.bset;
    return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator&=(basic_chset_8bit const& x)
{
    bset &= x.bset;
    return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator-=(basic_chset_8bit const& x)
{
    bset &= ~x.bset;
    return *this;
}
template <typename CharT>
inline basic_chset_8bit<CharT>&
basic_chset_8bit<CharT>::operator^=(basic_chset_8bit const& x)
{
    bset ^= x.bset;
    return *this;
}
}}
namespace boost { namespace spirit {
namespace utility { namespace impl {
    template <typename CharT, typename CharT2>
    void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
            CharT2 const* definition);
}}
template <typename CharT = char>
class chset: public char_parser<chset<CharT> > {
public:
                    chset();
                    chset(chset const& arg_);
    explicit chset(CharT arg_);
    explicit chset(anychar_parser arg_);
    explicit chset(nothing_parser arg_);
    explicit chset(chlit<CharT> const& arg_);
    explicit chset(range<CharT> const& arg_);
    explicit chset(negated_char_parser<chlit<CharT> > const& arg_);
    explicit chset(negated_char_parser<range<CharT> > const& arg_);
                    template <typename CharT2>
    explicit chset(CharT2 const* definition)
                    : ptr(new basic_chset<CharT>())
                    {
                        utility::impl::construct_chset(ptr, definition);
                    }
                    ~chset();
    chset& operator=(chset const& rhs);
    chset& operator=(CharT rhs);
    chset& operator=(anychar_parser rhs);
    chset& operator=(nothing_parser rhs);
    chset& operator=(chlit<CharT> const& rhs);
    chset& operator=(range<CharT> const& rhs);
    chset& operator=(negated_char_parser<chlit<CharT> > const& rhs);
    chset& operator=(negated_char_parser<range<CharT> > const& rhs);
    void set(range<CharT> const& arg_);
    void set(negated_char_parser<chlit<CharT> > const& arg_);
    void set(negated_char_parser<range<CharT> > const& arg_);
    void clear(range<CharT> const& arg_);
    void clear(negated_char_parser<range<CharT> > const& arg_);
    bool test(CharT ch) const;
    chset& inverse();
    void swap(chset& x);
    chset& operator|=(chset const& x);
    chset& operator&=(chset const& x);
    chset& operator-=(chset const& x);
    chset& operator^=(chset const& x);
private:
    boost::shared_ptr<basic_chset<CharT> > ptr;
};
template <typename CharT>
inline chset<CharT>
chset_p(chlit<CharT> const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(range<CharT> const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(negated_char_parser<chlit<CharT> > const& arg_)
{ return chset<CharT>(arg_); }
template <typename CharT>
inline chset<CharT>
chset_p(negated_char_parser<range<CharT> > const& arg_)
{ return chset<CharT>(arg_); }
inline chset<char>
chset_p(char const* init)
{ return chset<char>(init); }
inline chset<wchar_t>
chset_p(wchar_t const* init)
{ return chset<wchar_t>(init); }
inline chset<char>
chset_p(char ch)
{ return chset<char>(ch); }
inline chset<wchar_t>
chset_p(wchar_t ch)
{ return chset<wchar_t>(ch); }
inline chset<int>
chset_p(int ch)
{ return chset<int>(ch); }
inline chset<unsigned int>
chset_p(unsigned int ch)
{ return chset<unsigned int>(ch); }
inline chset<short>
chset_p(short ch)
{ return chset<short>(ch); }
inline chset<unsigned short>
chset_p(unsigned short ch)
{ return chset<unsigned short>(ch); }
inline chset<long>
chset_p(long ch)
{ return chset<long>(ch); }
inline chset<unsigned long>
chset_p(unsigned long ch)
{ return chset<unsigned long>(ch); }
inline chset<long long>
chset_p(long long ch)
{ return chset<long long>(ch); }
inline chset<unsigned long long>
chset_p(unsigned long long ch)
{ return chset<unsigned long long>(ch); }
}}
namespace boost { namespace spirit {
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) |= b;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) -= b;
}
template <typename CharT>
inline chset<CharT>
operator~(chset<CharT> const& a)
{
    return chset<CharT>(a).inverse();
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) &= b;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) ^= b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, range<CharT> const& b)
{
    chset<CharT> a_(a);
    a_.set(b);
    return a_;
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, range<CharT> const& b)
{
    chset<CharT> a_(a);
    if(b.first != std::numeric_limits<CharT>::min()) {
        a_.clear(range<CharT>(std::numeric_limits<CharT>::min(), b.first - 1));
    }
    if(b.last != std::numeric_limits<CharT>::max()) {
        a_.clear(range<CharT>(b.last + 1, std::numeric_limits<CharT>::max()));
    }
    return a_;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, range<CharT> const& b)
{
    chset<CharT> a_(a);
    a_.clear(b);
    return a_;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, range<CharT> const& b)
{
    return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(range<CharT> const& a, chset<CharT> const& b)
{
    chset<CharT> b_(b);
    b_.set(a);
    return b_;
}
template <typename CharT>
inline chset<CharT>
operator&(range<CharT> const& a, chset<CharT> const& b)
{
    chset<CharT> b_(b);
    if(a.first != std::numeric_limits<CharT>::min()) {
        b_.clear(range<CharT>(std::numeric_limits<CharT>::min(), a.first - 1));
    }
    if(a.last != std::numeric_limits<CharT>::max()) {
        b_.clear(range<CharT>(a.last + 1, std::numeric_limits<CharT>::max()));
    }
    return b_;
}
template <typename CharT>
inline chset<CharT>
operator-(range<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(range<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, CharT b)
{
    return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, CharT b)
{
    return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, CharT b)
{
    return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, CharT b)
{
    return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(CharT a, chset<CharT> const& b)
{
    return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(CharT a, chset<CharT> const& b)
{
    return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(CharT a, chset<CharT> const& b)
{
    return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(CharT a, chset<CharT> const& b)
{
    return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, chlit<CharT> const& b)
{
    return a | chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, chlit<CharT> const& b)
{
    return a & chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, chlit<CharT> const& b)
{
    return a - chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, chlit<CharT> const& b)
{
    return a ^ chset<CharT>(b.ch);
}
template <typename CharT>
inline chset<CharT>
operator|(chlit<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a.ch) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(chlit<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a.ch) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(chlit<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a.ch) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(chlit<CharT> const& a, chset<CharT> const& b)
{
    return chset<CharT>(a.ch) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
    return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
    return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
    return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
{
    return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) ^ b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
    return a | chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
    return a & chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
    return a - chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
{
    return a ^ chset<CharT>(b);
}
template <typename CharT>
inline chset<CharT>
operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) | b;
}
template <typename CharT>
inline chset<CharT>
operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) & b;
}
template <typename CharT>
inline chset<CharT>
operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) - b;
}
template <typename CharT>
inline chset<CharT>
operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
{
    return chset<CharT>(a) ^ b;
}
namespace impl {
    template <typename CharT>
    inline boost::spirit::range<CharT> const&
    full()
    {
        static boost::spirit::range<CharT> full_(
            std::numeric_limits<CharT>::min(),
            std::numeric_limits<CharT>::max());
        return full_;
    }
    template <typename CharT>
    inline boost::spirit::range<CharT> const&
    empty()
    {
        static boost::spirit::range<CharT> empty_;
        return empty_;
    }
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const&, anychar_parser)
{
    return chset<CharT>(impl::full<CharT>());
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& a, anychar_parser)
{
    return a;
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const&, anychar_parser)
{
    return chset<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, anychar_parser)
{
    return ~a;
}
template <typename CharT>
inline chset<CharT>
operator|(anychar_parser, chset<CharT> const& )
{
    return chset<CharT>(impl::full<CharT>());
}
template <typename CharT>
inline chset<CharT>
operator&(anychar_parser, chset<CharT> const& b)
{
    return b;
}
template <typename CharT>
inline chset<CharT>
operator-(anychar_parser, chset<CharT> const& b)
{
    return ~b;
}
template <typename CharT>
inline chset<CharT>
operator^(anychar_parser, chset<CharT> const& b)
{
    return ~b;
}
template <typename CharT>
inline chset<CharT>
operator|(chset<CharT> const& a, nothing_parser)
{
    return a;
}
template <typename CharT>
inline chset<CharT>
operator&(chset<CharT> const& , nothing_parser)
{
    return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator-(chset<CharT> const& a, nothing_parser)
{
    return a;
}
template <typename CharT>
inline chset<CharT>
operator^(chset<CharT> const& a, nothing_parser)
{
    return a;
}
template <typename CharT>
inline chset<CharT>
operator|(nothing_parser, chset<CharT> const& b)
{
    return b;
}
template <typename CharT>
inline chset<CharT>
operator&(nothing_parser, chset<CharT> const& )
{
    return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator-(nothing_parser, chset<CharT> const& )
{
    return impl::empty<CharT>();
}
template <typename CharT>
inline chset<CharT>
operator^(nothing_parser, chset<CharT> const& b)
{
    return b;
}
}}
namespace boost { namespace spirit {
template <typename CharT>
chset<CharT>
operator~(chset<CharT> const& a);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, range<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(range<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, chlit<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(chlit<CharT> const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
template <typename CharT>
chset<CharT>
operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, CharT b);
template <typename CharT>
chset<CharT>
operator|(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(CharT a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, anychar_parser b);
template <typename CharT>
chset<CharT>
operator|(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(anychar_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator|(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator&(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator-(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator^(chset<CharT> const& a, nothing_parser b);
template <typename CharT>
chset<CharT>
operator|(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator&(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator-(nothing_parser a, chset<CharT> const& b);
template <typename CharT>
chset<CharT>
operator^(nothing_parser a, chset<CharT> const& b);
}}
namespace boost { namespace spirit {
namespace utility { namespace impl {
    template <typename CharT>
    inline void
    detach(boost::shared_ptr<basic_chset<CharT> >& ptr)
    {
        if (!ptr.unique())
            ptr = boost::shared_ptr<basic_chset<CharT> >
                (new basic_chset<CharT>(*ptr));
    }
    template <typename CharT>
    inline void
    detach_clear(boost::shared_ptr<basic_chset<CharT> >& ptr)
    {
        if (ptr.unique())
            ptr->clear();
        else
            ptr.reset(new basic_chset<CharT>());
    }
    template <typename CharT, typename CharT2>
    void construct_chset(boost::shared_ptr<basic_chset<CharT> >& ptr,
            CharT2 const* definition)
    {
        CharT2 ch = *definition++;
        while (ch)
        {
            CharT2 next = *definition++;
            if (next == '-')
            {
                next = *definition++;
                if (next == 0)
                {
                    ptr->set(ch);
                    ptr->set('-');
                    break;
                }
                ptr->set(ch, next);
            }
            else
            {
                ptr->set(ch);
            }
            ch = next;
        }
    }
}}
template <typename CharT>
inline chset<CharT>::chset()
: ptr(new basic_chset<CharT>()) {}
template <typename CharT>
inline chset<CharT>::chset(chset const& arg_)
: ptr(new basic_chset<CharT>(*arg_.ptr)) {}
template <typename CharT>
inline chset<CharT>::chset(CharT arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_); }
template <typename CharT>
inline chset<CharT>::chset(anychar_parser arg_)
: ptr(new basic_chset<CharT>())
{
    ptr->set(
        std::numeric_limits<CharT>::min(),
        std::numeric_limits<CharT>::max()
    );
}
template <typename CharT>
inline chset<CharT>::chset(nothing_parser arg_)
: ptr(new basic_chset<CharT>()) {}
template <typename CharT>
inline chset<CharT>::chset(chlit<CharT> const& arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_.ch); }
template <typename CharT>
inline chset<CharT>::chset(range<CharT> const& arg_)
: ptr(new basic_chset<CharT>())
{ ptr->set(arg_.first, arg_.last); }
template <typename CharT>
inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_)
: ptr(new basic_chset<CharT>())
{
    set(arg_);
}
template <typename CharT>
inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_)
: ptr(new basic_chset<CharT>())
{
    set(arg_);
}
template <typename CharT>
inline chset<CharT>::~chset() {}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(chset const& rhs)
{
    ptr = rhs.ptr;
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(CharT rhs)
{
    utility::impl::detach_clear(ptr);
    ptr->set(rhs);
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(anychar_parser rhs)
{
    utility::impl::detach_clear(ptr);
    ptr->set(
        std::numeric_limits<CharT>::min(),
        std::numeric_limits<CharT>::max()
    );
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(nothing_parser rhs)
{
    utility::impl::detach_clear(ptr);
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(chlit<CharT> const& rhs)
{
    utility::impl::detach_clear(ptr);
    ptr->set(rhs.ch);
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(range<CharT> const& rhs)
{
    utility::impl::detach_clear(ptr);
    ptr->set(rhs.first, rhs.last);
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs)
{
    utility::impl::detach_clear(ptr);
    set(rhs);
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs)
{
    utility::impl::detach_clear(ptr);
    set(rhs);
    return *this;
}
template <typename CharT>
inline void
chset<CharT>::set(range<CharT> const& arg_)
{
    utility::impl::detach(ptr);
    ptr->set(arg_.first, arg_.last);
}
template <typename CharT>
inline void
chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_)
{
    utility::impl::detach(ptr);
    if(arg_.positive.ch != std::numeric_limits<CharT>::min()) {
        ptr->set(std::numeric_limits<CharT>::min(), arg_.positive.ch - 1);
    }
    if(arg_.positive.ch != std::numeric_limits<CharT>::max()) {
        ptr->set(arg_.positive.ch + 1, std::numeric_limits<CharT>::max());
    }
}
template <typename CharT>
inline void
chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_)
{
    utility::impl::detach(ptr);
    if(arg_.positive.first != std::numeric_limits<CharT>::min()) {
        ptr->set(std::numeric_limits<CharT>::min(), arg_.positive.first - 1);
    }
    if(arg_.positive.last != std::numeric_limits<CharT>::max()) {
        ptr->set(arg_.positive.last + 1, std::numeric_limits<CharT>::max());
    }
}
template <typename CharT>
inline void
chset<CharT>::clear(range<CharT> const& arg_)
{
    utility::impl::detach(ptr);
    ptr->clear(arg_.first, arg_.last);
}
template <typename CharT>
inline void
chset<CharT>::clear(negated_char_parser<range<CharT> > const& arg_)
{
    utility::impl::detach(ptr);
    if(arg_.positive.first != std::numeric_limits<CharT>::min()) {
        ptr->clear(std::numeric_limits<CharT>::min(), arg_.positive.first - 1);
    }
    if(arg_.positive.last != std::numeric_limits<CharT>::max()) {
        ptr->clear(arg_.positive.last + 1, std::numeric_limits<CharT>::max());
    }
}
template <typename CharT>
inline bool
chset<CharT>::test(CharT ch) const
{ return ptr->test(ch); }
template <typename CharT>
inline chset<CharT>&
chset<CharT>::inverse()
{
    utility::impl::detach(ptr);
    ptr->inverse();
    return *this;
}
template <typename CharT>
inline void
chset<CharT>::swap(chset& x)
{ ptr.swap(x.ptr); }
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator|=(chset const& x)
{
    utility::impl::detach(ptr);
    *ptr |= *x.ptr;
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator&=(chset const& x)
{
    utility::impl::detach(ptr);
    *ptr &= *x.ptr;
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator-=(chset const& x)
{
    utility::impl::detach(ptr);
    *ptr -= *x.ptr;
    return *this;
}
template <typename CharT>
inline chset<CharT>&
chset<CharT>::operator^=(chset const& x)
{
    utility::impl::detach(ptr);
    *ptr ^= *x.ptr;
    return *this;
}
}}
namespace boost { namespace spirit {
const unsigned long c_escapes = 1;
const unsigned long lex_escapes = c_escapes << 1;
namespace impl {
    template <unsigned long Flags, typename CharT>
    struct escape_char_action_parse {
        template <typename ParserT, typename ScannerT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const &p)
        {
            typedef CharT char_t;
            typedef typename ScannerT::iterator_t iterator_t;
            typedef typename parser_result<ParserT, ScannerT>::type result_t;
            if (scan.first != scan.last) {
                iterator_t save = scan.first;
                if (result_t hit = p.subject().parse(scan)) {
                    char_t unescaped;
                    scan.first = save;
                    if (*scan.first == '\\') {
                        ++scan.first;
                        switch (*scan.first) {
                        case 'b': unescaped = '\b'; ++scan.first; break;
                        case 't': unescaped = '\t'; ++scan.first; break;
                        case 'n': unescaped = '\n'; ++scan.first; break;
                        case 'f': unescaped = '\f'; ++scan.first; break;
                        case 'r': unescaped = '\r'; ++scan.first; break;
                        case '"': unescaped = '"'; ++scan.first; break;
                        case '\'': unescaped = '\''; ++scan.first; break;
                        case '\\': unescaped = '\\'; ++scan.first; break;
                        case 'x': case 'X':
                            {
                                char_t hex = 0;
                                char_t const lim =
                                    std::numeric_limits<char_t>::max() >> 4;
                                ++scan.first;
                                while (scan.first != scan.last)
                                {
                                    char_t c = *scan.first;
                                    if (hex > lim && impl::isxdigit_(c))
                                    {
                                        scan.first = save;
                                        return scan.no_match();
                                    }
                                    if (impl::isdigit_(c))
                                    {
                                        hex <<= 4;
                                        hex |= c - '0';
                                        ++scan.first;
                                    }
                                    else if (impl::isxdigit_(c))
                                    {
                                        hex <<= 4;
                                        c = impl::toupper_(c);
                                        hex |= c - 'A' + 0xA;
                                        ++scan.first;
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                                unescaped = hex;
                            }
                            break;
                        case '0': case '1': case '2': case '3':
                        case '4': case '5': case '6': case '7':
                            {
                                char_t oct = 0;
                                char_t const lim =
                                    std::numeric_limits<char_t>::max() >> 3;
                                while (scan.first != scan.last)
                                {
                                    char_t c = *scan.first;
                                    if (oct > lim && (c >= '0' && c <= '7'))
                                    {
                                        scan.first = save;
                                        return scan.no_match();
                                    }
                                    if (c >= '0' && c <= '7')
                                    {
                                        oct <<= 3;
                                        oct |= c - '0';
                                        ++scan.first;
                                    }
                                    else
                                    {
                                        break;
                                    }
                                }
                                unescaped = oct;
                            }
                            break;
                        default:
                            if (Flags & c_escapes)
                            {
                                scan.first = save;
                                return scan.no_match();
                            }
                            else
                            {
                                unescaped = *scan.first;
                                ++scan.first;
                            }
                            break;
                        }
                    }
                    else {
                        unescaped = *scan.first;
                        ++scan.first;
                    }
                    scan.do_action(p.predicate(), unescaped, save, scan.first);
                    return hit;
                }
            }
            return scan.no_match();
        }
    };
    template <typename CharT>
    struct escape_char_parse {
        template <typename ScannerT, typename ParserT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const &scan, ParserT const & )
        {
            typedef
                uint_parser<CharT, 8, 1,
                    std::numeric_limits<CharT>::digits / 3 + 1
                >
                oct_parser_t;
            typedef
                uint_parser<CharT, 16, 1,
                    std::numeric_limits<CharT>::digits / 4 + 1
                >
                hex_parser_t;
            typedef alternative<difference<anychar_parser, chlit<CharT> >,
                sequence<chlit<CharT>, alternative<alternative<oct_parser_t,
                sequence<inhibit_case<chlit<CharT> >, hex_parser_t > >,
                difference<difference<anychar_parser,
                inhibit_case<chlit<CharT> > >, oct_parser_t > > > >
                parser_t;
            static parser_t p =
                ( (anychar_p - CharT('\\'))
                | (CharT('\\') >>
                    ( oct_parser_t()
                     | as_lower_d[CharT('x')] >> hex_parser_t()
                     | (anychar_p - as_lower_d[CharT('x')] - oct_parser_t())
                    )
                ));
            ;
            return p.parse(scan);
        }
    };
}
}}
namespace boost { namespace spirit {
template <
    typename ParserT, typename ActionT,
    unsigned long Flags, typename CharT
>
struct escape_char_action
: public unary<ParserT,
        parser<escape_char_action<ParserT, ActionT, Flags, CharT> > >
{
    typedef escape_char_action
        <ParserT, ActionT, Flags, CharT> self_t;
    typedef action_parser_category parser_category_t;
    typedef unary<ParserT, parser<self_t> > base_t;
    template <typename ScannerT>
    struct result
    {
        typedef typename match_result<ScannerT, CharT>::type type;
    };
    escape_char_action(ParserT const& p, ActionT const& a)
    : base_t(p), actor(a) {}
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::escape_char_action_parse<Flags, CharT>::
            parse(scan, *this);
    }
    ActionT const& predicate() const { return actor; }
private:
    ActionT actor;
};
template <unsigned long Flags, typename CharT>
struct escape_char_action_parser_gen;
template <unsigned long Flags, typename CharT = char>
struct escape_char_parser :
    public parser<escape_char_parser<Flags, CharT> > {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( Flags == c_escapes || Flags == lex_escapes ) >)> boost_static_assert_typedef_118;
    typedef escape_char_parser<Flags, CharT> self_t;
    typedef
        escape_char_action_parser_gen<Flags, CharT>
        action_parser_generator_t;
    template <typename ScannerT>
    struct result {
        typedef typename match_result<ScannerT, CharT>::type type;
    };
    template <typename ActionT>
    escape_char_action<self_t, ActionT, Flags, CharT>
    operator[](ActionT const& actor) const
    {
        return escape_char_action<self_t, ActionT, Flags, CharT>(*this, actor);
    }
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const &scan) const
    {
        return impl::escape_char_parse<CharT>::parse(scan, *this);
    }
};
template <unsigned long Flags, typename CharT>
struct escape_char_action_parser_gen {
    template <typename ParserT, typename ActionT>
    static escape_char_action<ParserT, ActionT, Flags, CharT>
    generate (ParserT const &p, ActionT const &actor)
    {
        typedef
            escape_char_action<ParserT, ActionT, Flags, CharT>
            action_parser_t;
        return action_parser_t(p, actor);
    }
};
const escape_char_parser<lex_escapes> lex_escape_ch_p =
    escape_char_parser<lex_escapes>();
const escape_char_parser<c_escapes> c_escape_ch_p =
    escape_char_parser<c_escapes>();
}}
namespace boost { namespace spirit {
    template < class FunctorT >
    struct functor_parser : public parser<functor_parser<FunctorT> >
    {
        FunctorT functor;
        functor_parser(): functor() {}
        functor_parser(FunctorT const& functor_): functor(functor_) {}
        typedef typename FunctorT::result_t functor_result_t;
        typedef functor_parser<FunctorT> self_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, functor_result_t>::type
            type;
        };
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            typedef typename parser_result<self_t, ScannerT>::type result_t;
            typedef typename ScannerT::value_t value_t;
            typedef typename ScannerT::iterator_t iterator_t;
            iterator_t const s(scan.first);
            functor_result_t result;
            std::ptrdiff_t len = functor(scan, result);
            if (len < 0)
                return scan.no_match();
            else
                return scan.create_match(std::size_t(len), result, s, scan.first);
        }
    };
}}
namespace boost { namespace spirit {
    template <typename ParserT, typename ExactT>
    class fixed_loop
    : public unary<ParserT, parser <fixed_loop <ParserT, ExactT> > >
    {
    public:
        typedef fixed_loop<ParserT, ExactT> self_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        fixed_loop (ParserT const & subject, ExactT const & exact)
        : base_t(subject), m_exact(exact) {}
        template <typename ScannerT>
        typename parser_result <self_t, ScannerT>::type
        parse (ScannerT const & scan) const
        {
            typename parser_result<self_t, ScannerT>::type hit(0);
            std::size_t n = m_exact;
            for (std::size_t i = 0; i < n; ++i)
            {
                typename parser_result<self_t, ScannerT>::type next
                    = this->subject().parse(scan);
                if (!next)
                    return scan.no_match();
                hit.concat(next);
            }
            return hit;
        }
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, nil_t>::type type;
        };
    private:
        ExactT m_exact;
    };
    template <typename ParserT, typename MinT, typename MaxT>
    class finite_loop
    : public unary<ParserT, parser<finite_loop<ParserT, MinT, MaxT> > >
    {
    public:
        typedef finite_loop <ParserT, MinT, MaxT> self_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        finite_loop (ParserT const & subject, MinT const & min, MaxT const & max)
        : base_t(subject), m_min(min), m_max(max) {}
        template <typename ScannerT>
        typename parser_result <self_t, ScannerT>::type
        parse(ScannerT const & scan) const
        {
            ;
            typename parser_result<self_t, ScannerT>::type hit(0);
            std::size_t n1 = m_min;
            std::size_t n2 = m_max;
            for (std::size_t i = 0; i < n2; ++i)
            {
                typename ScannerT::iterator_t save = scan.first;
                typename parser_result<self_t, ScannerT>::type next
                    = this->subject().parse(scan);
                if (!next)
                {
                    if (i >= n1)
                    {
                        scan.first = save;
                        break;
                    }
                    else
                    {
                        return scan.no_match();
                    }
                }
                hit.concat(next);
            }
            return hit;
        }
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, nil_t>::type type;
        };
    private:
        MinT m_min;
        MaxT m_max;
    };
    struct more_t {};
    more_t const more = more_t ();
    template <typename ParserT, typename MinT>
    class infinite_loop
     : public unary<ParserT, parser<infinite_loop<ParserT, MinT> > >
    {
    public:
        typedef infinite_loop <ParserT, MinT> self_t;
        typedef unary<ParserT, parser<self_t> > base_t;
        infinite_loop (
            ParserT const& subject,
            MinT const& min,
            more_t const&
        )
        : base_t(subject), m_min(min) {}
        template <typename ScannerT>
        typename parser_result <self_t, ScannerT>::type
        parse(ScannerT const & scan) const
        {
            typename parser_result<self_t, ScannerT>::type hit(0);
            std::size_t n = m_min;
            for (std::size_t i = 0; ; ++i)
            {
                typename ScannerT::iterator_t save = scan.first;
                typename parser_result<self_t, ScannerT>::type next
                    = this->subject().parse(scan);
                if (!next)
                {
                    if (i >= n)
                    {
                        scan.first = save;
                        break;
                    }
                    else
                    {
                        return scan.no_match();
                    }
                }
                hit.concat(next);
            }
            return hit;
        }
        template <typename ScannerT>
        struct result
        {
            typedef typename match_result<ScannerT, nil_t>::type type;
        };
        private:
        MinT m_min;
    };
    template <typename ExactT>
    struct fixed_loop_gen
    {
        fixed_loop_gen (ExactT const & exact)
        : m_exact (exact) {}
        template <typename ParserT>
        fixed_loop <ParserT, ExactT>
        operator[](parser <ParserT> const & subject) const
        {
            return fixed_loop <ParserT, ExactT> (subject.derived (), m_exact);
        }
        ExactT m_exact;
    };
    namespace impl {
        template <typename ParserT, typename MinT, typename MaxT>
        struct loop_traits
        {
            typedef typename mpl::if_<
                boost::is_same<MaxT, more_t>,
                infinite_loop<ParserT, MinT>,
                finite_loop<ParserT, MinT, MaxT>
            >::type type;
        };
    }
    template <typename MinT, typename MaxT>
    struct nonfixed_loop_gen
    {
       nonfixed_loop_gen (MinT min, MaxT max)
        : m_min (min), m_max (max) {}
       template <typename ParserT>
       typename impl::loop_traits<ParserT, MinT, MaxT>::type
       operator[](parser <ParserT> const & subject) const
       {
           typedef typename impl::loop_traits<ParserT, MinT, MaxT>::type ret_t;
           return ret_t(
                subject.derived(),
                m_min,
                m_max);
       }
       MinT m_min;
       MaxT m_max;
    };
    template <typename ExactT>
    fixed_loop_gen <ExactT>
    repeat_p(ExactT const & exact)
    {
        return fixed_loop_gen <ExactT> (exact);
    }
    template <typename MinT, typename MaxT>
    nonfixed_loop_gen <MinT, MaxT>
    repeat_p(MinT const & min, MaxT const & max)
    {
        return nonfixed_loop_gen <MinT, MaxT> (min, max);
    }
}}
namespace boost { namespace spirit {
struct non_nested_refactoring { typedef non_nested_refactoring embed_t; };
struct self_nested_refactoring { typedef self_nested_refactoring embed_t; };
namespace impl {
    template <typename CategoryT>
    struct refactor_unary_nested {
        template <
            typename ParserT, typename NestedT,
            typename ScannerT, typename BinaryT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
            NestedT const& )
        {
            return binary.parse(scan);
        }
    };
    template <>
    struct refactor_unary_nested<unary_parser_category> {
        template <
            typename ParserT, typename ScannerT, typename BinaryT,
            typename NestedT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
            NestedT const& nested_d)
        {
            typedef typename BinaryT::parser_generator_t op_t;
            typedef
                typename BinaryT::left_t::parser_generator_t
                unary_t;
            return
                unary_t::generate(
                    nested_d[
                        op_t::generate(binary.left().subject(), binary.right())
                    ]
                ).parse(scan);
        }
    };
    template <typename CategoryT>
    struct refactor_unary_non_nested {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
        {
            return binary.parse(scan);
        }
    };
    template <>
    struct refactor_unary_non_nested<unary_parser_category> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
        {
            typedef typename BinaryT::parser_generator_t op_t;
            typedef
                typename BinaryT::left_t::parser_generator_t
                unary_t;
            return unary_t::generate(
                op_t::generate(binary.left().subject(), binary.right())
            ).parse(scan);
        }
    };
    template <typename NestedT>
    struct refactor_unary_type {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            NestedT const& nested_d)
        {
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            return refactor_unary_nested<parser_category_t>::
                    parse(p, scan, binary, nested_d);
        }
    };
    template <>
    struct refactor_unary_type<non_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            non_nested_refactoring const&)
        {
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            return refactor_unary_non_nested<parser_category_t>::
                    parse(p, scan, binary);
        }
    };
    template <>
    struct refactor_unary_type<self_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            self_nested_refactoring const &nested_tag)
        {
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            typedef typename ParserT::parser_generator_t parser_generator_t;
            parser_generator_t nested_d(nested_tag);
            return refactor_unary_nested<parser_category_t>::
                    parse(p, scan, binary, nested_d);
        }
    };
    template <typename CategoryT>
    struct refactor_action_nested {
        template <
            typename ParserT, typename ScannerT, typename BinaryT,
            typename NestedT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
            NestedT const& nested_d)
        {
            return nested_d[binary].parse(scan);
        }
    };
    template <>
    struct refactor_action_nested<action_parser_category> {
        template <
            typename ParserT, typename ScannerT, typename BinaryT,
            typename NestedT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary,
            NestedT const& nested_d)
        {
            typedef typename BinaryT::parser_generator_t binary_gen_t;
            return (
                nested_d[
                    binary_gen_t::generate(
                        binary.left().subject(),
                        binary.right()
                    )
                ][binary.left().predicate()]
            ).parse(scan);
        }
    };
    template <typename CategoryT>
    struct refactor_action_non_nested {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
        {
            return binary.parse(scan);
        }
    };
    template <>
    struct refactor_action_non_nested<action_parser_category> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, BinaryT const& binary)
        {
            typedef typename BinaryT::parser_generator_t binary_gen_t;
            return (
                binary_gen_t::generate(
                    binary.left().subject(),
                    binary.right()
                )[binary.left().predicate()]
            ).parse(scan);
        }
    };
    template <typename NestedT>
    struct refactor_action_type {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            NestedT const& nested_d)
        {
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            return refactor_action_nested<parser_category_t>::
                    parse(p, scan, binary, nested_d);
        }
    };
    template <>
    struct refactor_action_type<non_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            non_nested_refactoring const&)
        {
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            return refactor_action_non_nested<parser_category_t>::
                parse(p, scan, binary);
        }
    };
    template <>
    struct refactor_action_type<self_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename BinaryT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, BinaryT const& binary,
            self_nested_refactoring const &nested_tag)
        {
            typedef typename ParserT::parser_generator_t parser_generator_t;
            typedef
                typename BinaryT::left_t::parser_category_t
                parser_category_t;
            parser_generator_t nested_d(nested_tag);
            return refactor_action_nested<parser_category_t>::
                    parse(p, scan, binary, nested_d);
        }
    };
    template <typename CategoryT>
    struct attach_action_nested {
        template <
            typename ParserT, typename ScannerT, typename ActionT,
            typename NestedT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, ActionT const &action,
            NestedT const& nested_d)
        {
            return action.parse(scan);
        }
    };
    template <>
    struct attach_action_nested<binary_parser_category> {
        template <
            typename ParserT, typename ScannerT, typename ActionT,
            typename NestedT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, ActionT const &action,
            NestedT const& nested_d)
        {
            typedef
                typename ActionT::subject_t::parser_generator_t
                binary_gen_t;
            return (
                binary_gen_t::generate(
                    nested_d[action.subject().left()[action.predicate()]],
                    nested_d[action.subject().right()[action.predicate()]]
                )
            ).parse(scan);
        }
    };
    template <typename CategoryT>
    struct attach_action_non_nested {
        template <typename ParserT, typename ScannerT, typename ActionT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, ActionT const &action)
        {
            return action.parse(scan);
        }
    };
    template <>
    struct attach_action_non_nested<binary_parser_category> {
        template <typename ParserT, typename ScannerT, typename ActionT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &, ScannerT const& scan, ActionT const &action)
        {
            typedef
                typename ActionT::subject_t::parser_generator_t
                binary_gen_t;
            return (
                binary_gen_t::generate(
                    action.subject().left()[action.predicate()],
                    action.subject().right()[action.predicate()]
                )
            ).parse(scan);
        }
    };
    template <typename NestedT>
    struct attach_action_type {
        template <typename ParserT, typename ScannerT, typename ActionT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, ActionT const& action,
            NestedT const& nested_d)
        {
            typedef
                typename ActionT::subject_t::parser_category_t
                parser_category_t;
            return attach_action_nested<parser_category_t>::
                    parse(p, scan, action, nested_d);
        }
    };
    template <>
    struct attach_action_type<non_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename ActionT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, ActionT const &action,
            non_nested_refactoring const&)
        {
            typedef
                typename ActionT::subject_t::parser_category_t
                parser_category_t;
            return attach_action_non_nested<parser_category_t>::
                parse(p, scan, action);
        }
    };
    template <>
    struct attach_action_type<self_nested_refactoring> {
        template <typename ParserT, typename ScannerT, typename ActionT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const &p, ScannerT const& scan, ActionT const &action,
            self_nested_refactoring const& nested_tag)
        {
            typedef typename ParserT::parser_generator_t parser_generator_t;
            typedef
                typename ActionT::subject_t::parser_category_t
                parser_category_t;
            parser_generator_t nested_d(nested_tag);
            return attach_action_nested<parser_category_t>::
                    parse(p, scan, action, nested_d);
        }
    };
}
}}
namespace boost { namespace spirit {
template <typename NestedT = non_nested_refactoring>
class refactor_unary_gen;
template <typename BinaryT, typename NestedT = non_nested_refactoring>
class refactor_unary_parser :
    public parser<refactor_unary_parser<BinaryT, NestedT> > {
public:
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( boost::is_convertible<typename BinaryT::parser_category_t, binary_parser_category>::value ) ) >)> boost_static_assert_typedef_59;
    refactor_unary_parser(BinaryT const& binary_, NestedT const& nested_)
    : binary(binary_), nested(nested_) {}
    typedef refactor_unary_parser<BinaryT, NestedT> self_t;
    typedef refactor_unary_gen<NestedT> parser_generator_t;
    typedef typename BinaryT::left_t::parser_category_t parser_category_t;
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::refactor_unary_type<NestedT>::
            parse(*this, scan, binary, nested);
    }
private:
    typename as_parser<BinaryT>::type::embed_t binary;
    typename NestedT::embed_t nested;
};
template <typename NestedT>
class refactor_unary_gen {
public:
    typedef refactor_unary_gen<NestedT> embed_t;
    refactor_unary_gen(NestedT const& nested_ = non_nested_refactoring())
    : nested(nested_) {}
    template <typename ParserT>
    refactor_unary_parser<ParserT, NestedT>
    operator[](parser<ParserT> const& subject) const
    {
        return refactor_unary_parser<ParserT, NestedT>
            (subject.derived(), nested);
    }
private:
    typename NestedT::embed_t nested;
};
const refactor_unary_gen<> refactor_unary_d = refactor_unary_gen<>();
template <typename NestedT = non_nested_refactoring>
class refactor_action_gen;
template <typename BinaryT, typename NestedT = non_nested_refactoring>
class refactor_action_parser :
    public parser<refactor_action_parser<BinaryT, NestedT> > {
public:
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( boost::is_convertible<typename BinaryT::parser_category_t, binary_parser_category>::value ) ) >)> boost_static_assert_typedef_142;
    refactor_action_parser(BinaryT const& binary_, NestedT const& nested_)
    : binary(binary_), nested(nested_) {}
    typedef refactor_action_parser<BinaryT, NestedT> self_t;
    typedef refactor_action_gen<NestedT> parser_generator_t;
    typedef typename BinaryT::left_t::parser_category_t parser_category_t;
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::refactor_action_type<NestedT>::
            parse(*this, scan, binary, nested);
    }
private:
    typename as_parser<BinaryT>::type::embed_t binary;
    typename NestedT::embed_t nested;
};
template <typename NestedT>
class refactor_action_gen {
public:
    typedef refactor_action_gen<NestedT> embed_t;
    refactor_action_gen(NestedT const& nested_ = non_nested_refactoring())
    : nested(nested_) {}
    template <typename ParserT>
    refactor_action_parser<ParserT, NestedT>
    operator[](parser<ParserT> const& subject) const
    {
        return refactor_action_parser<ParserT, NestedT>
            (subject.derived(), nested);
    }
private:
    typename NestedT::embed_t nested;
};
const refactor_action_gen<> refactor_action_d = refactor_action_gen<>();
template <typename NestedT = non_nested_refactoring>
class attach_action_gen;
template <typename ActionT, typename NestedT = non_nested_refactoring>
class attach_action_parser :
    public parser<attach_action_parser<ActionT, NestedT> > {
public:
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( boost::is_convertible<typename ActionT::parser_category_t, action_parser_category>::value ) ) >)> boost_static_assert_typedef_224;
    attach_action_parser(ActionT const& actor_, NestedT const& nested_)
    : actor(actor_), nested(nested_) {}
    typedef attach_action_parser<ActionT, NestedT> self_t;
    typedef attach_action_gen<NestedT> parser_generator_t;
    typedef typename ActionT::parser_category_t parser_category_t;
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::attach_action_type<NestedT>::
            parse(*this, scan, actor, nested);
    }
private:
    typename as_parser<ActionT>::type::embed_t actor;
    typename NestedT::embed_t nested;
};
template <typename NestedT>
class attach_action_gen {
public:
    typedef attach_action_gen<NestedT> embed_t;
    attach_action_gen(NestedT const& nested_ = non_nested_refactoring())
    : nested(nested_) {}
    template <typename ParserT, typename ActionT>
    attach_action_parser<action<ParserT, ActionT>, NestedT>
    operator[](action<ParserT, ActionT> const& actor) const
    {
        return attach_action_parser<action<ParserT, ActionT>, NestedT>
            (actor, nested);
    }
private:
    typename NestedT::embed_t nested;
};
const attach_action_gen<> attach_action_d = attach_action_gen<>();
}}
namespace boost { namespace spirit {
struct is_nested {};
struct non_nested {};
struct is_lexeme {};
struct non_lexeme {};
namespace impl {
    template <typename LexemeT>
    struct select_confix_parse_lexeme;
    template <>
    struct select_confix_parse_lexeme<is_lexeme> {
        template <typename ParserT, typename ScannerT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const& p, ScannerT const& scan)
        {
            typedef typename parser_result<ParserT, ScannerT>::type result_t;
            return contiguous_parser_parse<result_t>(p, scan, scan);
        }
    };
    template <>
    struct select_confix_parse_lexeme<non_lexeme> {
        template <typename ParserT, typename ScannerT>
        static typename parser_result<ParserT, ScannerT>::type
        parse(ParserT const& p, ScannerT const& scan)
        {
            return p.parse(scan);
        }
    };
    template <typename NestedT>
    struct select_confix_parse_refactor;
    template <>
    struct select_confix_parse_refactor<is_nested> {
        template <
            typename LexemeT, typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            LexemeT const &, ParserT const& this_, ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
            const refactor_t refactor_body_d = refactor_t(refactor_unary_d);
            return select_confix_parse_lexeme<LexemeT>::parse((
                            open
                        >> (this_ | refactor_body_d[expr - close])
                        >> close
                    ), scan);
        }
    };
    template <>
    struct select_confix_parse_refactor<non_nested> {
        template <
            typename LexemeT, typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            LexemeT const &, ParserT const& , ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
            const refactor_t refactor_body_d = refactor_t(refactor_unary_d);
            return select_confix_parse_lexeme<LexemeT>::parse((
                            open
                        >> refactor_body_d[expr - close]
                        >> close
                    ), scan);
        }
    };
    template <typename NestedT>
    struct select_confix_parse_no_refactor;
    template <>
    struct select_confix_parse_no_refactor<is_nested> {
        template <
            typename LexemeT, typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            LexemeT const &, ParserT const& this_, ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            return select_confix_parse_lexeme<LexemeT>::parse((
                            open
                        >> (this_ | (expr - close))
                        >> close
                    ), scan);
        }
    };
    template <>
    struct select_confix_parse_no_refactor<non_nested> {
        template <
            typename LexemeT, typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            LexemeT const &, ParserT const & , ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            return select_confix_parse_lexeme<LexemeT>::parse((
                            open
                        >> (expr - close)
                        >> close
                    ), scan);
        }
    };
    template <typename CategoryT>
    struct confix_parser_type {
        template <
            typename NestedT, typename LexemeT,
            typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            NestedT const &, LexemeT const &lexeme,
            ParserT const& this_, ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            return select_confix_parse_refactor<NestedT>::
                parse(lexeme, this_, scan, open, expr, close);
        }
    };
    template <>
    struct confix_parser_type<plain_parser_category> {
        template <
            typename NestedT, typename LexemeT,
            typename ParserT, typename ScannerT,
            typename OpenT, typename ExprT, typename CloseT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(
            NestedT const &, LexemeT const &lexeme,
            ParserT const& this_, ScannerT const& scan,
            OpenT const& open, ExprT const& expr, CloseT const& close)
        {
            return select_confix_parse_no_refactor<NestedT>::
                parse(lexeme, this_, scan, open, expr, close);
        }
    };
}
}}
namespace boost { namespace spirit {
template<typename NestedT = non_nested, typename LexemeT = non_lexeme>
struct confix_parser_gen;
template <
    typename OpenT, typename ExprT, typename CloseT, typename CategoryT,
    typename NestedT = non_nested, typename LexemeT = non_lexeme
>
struct confix_parser :
    public parser<
        confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT>
    >
{
    typedef
        confix_parser<OpenT, ExprT, CloseT, CategoryT, NestedT, LexemeT>
        self_t;
    confix_parser(OpenT const &open_, ExprT const &expr_, CloseT const &close_)
    : open(open_), expr(expr_), close(close_)
    {}
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::confix_parser_type<CategoryT>::
            parse(NestedT(), LexemeT(), *this, scan, open, expr, close);
    }
private:
    typename as_parser<OpenT>::type::embed_t open;
    typename as_parser<ExprT>::type::embed_t expr;
    typename as_parser<CloseT>::type::embed_t close;
};
template<typename NestedT, typename LexemeT>
struct confix_parser_gen
{
    template<typename StartT, typename ExprT, typename EndT>
    confix_parser<
        typename as_parser<StartT>::type,
        typename as_parser<ExprT>::type,
        typename as_parser<EndT>::type,
        typename as_parser<ExprT>::type::parser_category_t,
        NestedT,
        LexemeT
    >
    operator()(
        StartT const &start_, ExprT const &expr_, EndT const &end_) const
    {
        typedef typename as_parser<StartT>::type start_t;
        typedef typename as_parser<ExprT>::type expr_t;
        typedef typename as_parser<EndT>::type end_t;
        typedef
            typename as_parser<ExprT>::type::parser_category_t
            parser_category_t;
        typedef
            confix_parser<
                start_t, expr_t, end_t, parser_category_t, NestedT, LexemeT
            >
            return_t;
        return return_t(
            as_parser<StartT>::convert(start_),
            as_parser<ExprT>::convert(expr_),
            as_parser<EndT>::convert(end_)
        );
    }
    template<typename StartT, typename ExprT, typename EndT>
    confix_parser<
        typename as_parser<StartT>::type,
        typename as_parser<ExprT>::type,
        typename as_parser<EndT>::type,
        plain_parser_category,
        NestedT,
        LexemeT
    >
    direct(StartT const &start_, ExprT const &expr_, EndT const &end_) const
    {
        typedef typename as_parser<StartT>::type start_t;
        typedef typename as_parser<ExprT>::type expr_t;
        typedef typename as_parser<EndT>::type end_t;
        typedef plain_parser_category parser_category_t;
        typedef
            confix_parser<
                start_t, expr_t, end_t, parser_category_t, NestedT, LexemeT
            >
            return_t;
        return return_t(
            as_parser<StartT>::convert(start_),
            as_parser<ExprT>::convert(expr_),
            as_parser<EndT>::convert(end_)
        );
    }
};
const confix_parser_gen<non_nested, non_lexeme> confix_p =
    confix_parser_gen<non_nested, non_lexeme>();
template<typename NestedT>
struct comment_parser_gen
{
    template<typename StartT>
    confix_parser<
        typename as_parser<StartT>::type,
        kleene_star<anychar_parser>,
        alternative<eol_parser, end_parser>,
        unary_parser_category,
        NestedT,
        is_lexeme
    >
    operator() (StartT const &start_) const
    {
        typedef typename as_parser<StartT>::type start_t;
        typedef kleene_star<anychar_parser> expr_t;
        typedef alternative<eol_parser, end_parser> end_t;
        typedef unary_parser_category parser_category_t;
        typedef
            confix_parser<
                start_t, expr_t, end_t, parser_category_t, NestedT, is_lexeme
            >
            return_t;
        return return_t(
            as_parser<StartT>::convert(start_),
            *anychar_p,
            eol_p | end_p
        );
    }
    template<typename StartT, typename EndT>
    confix_parser<
        typename as_parser<StartT>::type,
        kleene_star<anychar_parser>,
        typename as_parser<EndT>::type,
        unary_parser_category,
        NestedT,
        is_lexeme
    >
    operator() (StartT const &start_, EndT const &end_) const
    {
        typedef typename as_parser<StartT>::type start_t;
        typedef kleene_star<anychar_parser> expr_t;
        typedef typename as_parser<EndT>::type end_t;
        typedef unary_parser_category parser_category_t;
        typedef
            confix_parser<
                start_t, expr_t, end_t, parser_category_t, NestedT, is_lexeme
            >
            return_t;
        return return_t(
            as_parser<StartT>::convert(start_),
            *anychar_p,
            as_parser<EndT>::convert(end_)
        );
    }
};
const comment_parser_gen<non_nested> comment_p =
    comment_parser_gen<non_nested>();
template<typename OpenT, typename CloseT>
struct comment_nest_parser:
    public parser<comment_nest_parser<OpenT, CloseT> >
{
    typedef comment_nest_parser<OpenT, CloseT> self_t;
    comment_nest_parser(OpenT const &open_, CloseT const &close_):
        open(open_), close(close_)
    {}
    template<typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const &scan) const
    {
        return do_parse(
            open >> *(*this | (anychar_p - close)) >> close,
            scan);
    }
private:
    template<typename ParserT, typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
        do_parse(ParserT const &p, ScannerT const &scan) const
    {
        return
            impl::contiguous_parser_parse<
                typename parser_result<ParserT, ScannerT>::type
            >(p, scan, scan);
    }
    typename as_parser<OpenT>::type::embed_t open;
    typename as_parser<CloseT>::type::embed_t close;
};
template<typename OpenT, typename CloseT>
inline
comment_nest_parser<
    typename as_parser<OpenT>::type,
    typename as_parser<CloseT>::type
>
    comment_nest_p(OpenT const &open, CloseT const &close)
{
    return
        comment_nest_parser<
            typename as_parser<OpenT>::type,
            typename as_parser<CloseT>::type
        >(
            as_parser<OpenT>::convert(open),
            as_parser<CloseT>::convert(close)
        );
}
}}
namespace boost { namespace spirit {
struct no_list_endtoken { typedef no_list_endtoken embed_t; };
namespace impl {
    template <typename EndT>
    struct select_list_parse_refactor {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& ,
            ItemT const &item, DelimT const &delim, EndT const &end)
        {
            typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
            const refactor_t refactor_item_d = refactor_t(refactor_unary_d);
            return (
                    refactor_item_d[item - (end | delim)]
                >> *(delim >> refactor_item_d[item - (end | delim)])
                >> !(delim >> end)
            ).parse(scan);
        }
    };
    template <>
    struct select_list_parse_refactor<no_list_endtoken> {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& ,
            ItemT const &item, DelimT const &delim, no_list_endtoken const&)
        {
            typedef refactor_action_gen<refactor_unary_gen<> > refactor_t;
            const refactor_t refactor_item_d = refactor_t(refactor_unary_d);
            return (
                    refactor_item_d[item - delim]
                >> *(delim >> refactor_item_d[item - delim])
            ).parse(scan);
        }
    };
    template <typename EndT>
    struct select_list_parse_no_refactor {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& ,
            ItemT const &item, DelimT const &delim, EndT const &end)
        {
            return (
                    (item - (end | delim))
                >> *(delim >> (item - (end | delim)))
                >> !(delim >> end)
            ).parse(scan);
        }
    };
    template <>
    struct select_list_parse_no_refactor<no_list_endtoken> {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& ,
            ItemT const &item, DelimT const &delim, no_list_endtoken const&)
        {
            return (
                    (item - delim)
                >> *(delim >> (item - delim))
            ).parse(scan);
        }
    };
    template <typename CategoryT>
    struct list_parser_type {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT, typename EndT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& p,
              ItemT const &item, DelimT const &delim, EndT const &end)
        {
            return select_list_parse_refactor<EndT>::
                parse(scan, p, item, delim, end);
        }
    };
    template <>
    struct list_parser_type<plain_parser_category> {
        template <
            typename ParserT, typename ScannerT,
            typename ItemT, typename DelimT, typename EndT
        >
        static typename parser_result<ParserT, ScannerT>::type
        parse(ScannerT const& scan, ParserT const& p,
              ItemT const &item, DelimT const &delim, EndT const &end)
        {
            return select_list_parse_no_refactor<EndT>::
                parse(scan, p, item, delim, end);
        }
    };
}
}}
namespace boost { namespace spirit {
template <
    typename ItemT, typename DelimT, typename EndT = no_list_endtoken,
    typename CategoryT = plain_parser_category
>
struct list_parser :
    public parser<list_parser<ItemT, DelimT, EndT, CategoryT> > {
    typedef list_parser<ItemT, DelimT, EndT, CategoryT> self_t;
    typedef CategoryT parser_category_t;
    list_parser(ItemT const &item_, DelimT const &delim_,
        EndT const& end_ = no_list_endtoken())
    : item(item_), delim(delim_), end(end_)
    {}
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        return impl::list_parser_type<CategoryT>
            ::parse(scan, *this, item, delim, end);
    }
private:
    typename as_parser<ItemT>::type::embed_t item;
    typename as_parser<DelimT>::type::embed_t delim;
    typename as_parser<EndT>::type::embed_t end;
};
template <typename CharT = char>
struct list_parser_gen :
    public list_parser<kleene_star<anychar_parser>, chlit<CharT> >
{
    typedef list_parser_gen<CharT> self_t;
    list_parser_gen()
    : list_parser<kleene_star<anychar_parser>, chlit<CharT> >
        (*anychar_p, chlit<CharT>(','))
    {}
    template<typename DelimT>
    list_parser<
        kleene_star<anychar_parser>,
        typename as_parser<DelimT>::type,
        no_list_endtoken,
        unary_parser_category
    >
    operator()(DelimT const &delim_) const
    {
        typedef kleene_star<anychar_parser> item_t;
        typedef typename as_parser<DelimT>::type delim_t;
        typedef
            list_parser<item_t, delim_t, no_list_endtoken, unary_parser_category>
            return_t;
        return return_t(*anychar_p, as_parser<DelimT>::convert(delim_));
    }
    template<typename ItemT, typename DelimT>
    list_parser<
        typename as_parser<ItemT>::type,
        typename as_parser<DelimT>::type,
        no_list_endtoken,
        typename as_parser<ItemT>::type::parser_category_t
    >
    operator()(ItemT const &item_, DelimT const &delim_) const
    {
        typedef typename as_parser<ItemT>::type item_t;
        typedef typename as_parser<DelimT>::type delim_t;
        typedef list_parser<item_t, delim_t, no_list_endtoken,
                typename item_t::parser_category_t>
            return_t;
        return return_t(
            as_parser<ItemT>::convert(item_),
            as_parser<DelimT>::convert(delim_)
        );
    }
    template<typename ItemT, typename DelimT, typename EndT>
    list_parser<
        typename as_parser<ItemT>::type,
        typename as_parser<DelimT>::type,
        typename as_parser<EndT>::type
    >
    operator()(
        ItemT const &item_, DelimT const &delim_, EndT const &end_) const
    {
        typedef typename as_parser<ItemT>::type item_t;
        typedef typename as_parser<DelimT>::type delim_t;
        typedef typename as_parser<EndT>::type end_t;
        typedef list_parser<item_t, delim_t, end_t,
                typename item_t::parser_category_t>
            return_t;
        return return_t(
            as_parser<ItemT>::convert(item_),
            as_parser<DelimT>::convert(delim_),
            as_parser<EndT>::convert(end_)
        );
    }
    template<typename ItemT, typename DelimT>
    list_parser<
        typename as_parser<ItemT>::type,
        typename as_parser<DelimT>::type,
        no_list_endtoken,
        plain_parser_category
    >
    direct(ItemT const &item_, DelimT const &delim_) const
    {
        typedef typename as_parser<ItemT>::type item_t;
        typedef typename as_parser<DelimT>::type delim_t;
        typedef list_parser<item_t, delim_t, no_list_endtoken,
                plain_parser_category>
            return_t;
        return return_t(
            as_parser<ItemT>::convert(item_),
            as_parser<DelimT>::convert(delim_)
        );
    }
    template<typename ItemT, typename DelimT, typename EndT>
    list_parser<
        typename as_parser<ItemT>::type,
        typename as_parser<DelimT>::type,
        typename as_parser<EndT>::type,
        plain_parser_category
    >
    direct(
        ItemT const &item_, DelimT const &delim_, EndT const &end_) const
    {
        typedef typename as_parser<ItemT>::type item_t;
        typedef typename as_parser<DelimT>::type delim_t;
        typedef typename as_parser<EndT>::type end_t;
        typedef
            list_parser<item_t, delim_t, end_t, plain_parser_category>
            return_t;
        return return_t(
            as_parser<ItemT>::convert(item_),
            as_parser<DelimT>::convert(delim_),
            as_parser<EndT>::convert(end_)
        );
    }
};
const list_parser_gen<> list_p = list_parser_gen<>();
}}
namespace boost {
    namespace spirit {
template <typename CharT = char, typename TailT = chset<CharT> >
class distinct_parser
{
public:
    typedef
        contiguous<
            sequence<
                chseq<CharT const*>,
                negated_empty_match_parser<
                    TailT
                >
            >
        >
            result_t;
    distinct_parser()
    : tail(chset<CharT>())
    {
    }
    explicit distinct_parser(parser<TailT> const & tail_)
    : tail(tail_.derived())
    {
    }
    explicit distinct_parser(CharT const* letters)
    : tail(chset_p(letters))
    {
    }
    result_t operator()(CharT const* str) const
    {
        return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)];
    }
    TailT tail;
};
template <typename CharT = char, typename TailT = chset<CharT> >
class distinct_directive
{
public:
    template<typename ParserT>
    struct result {
        typedef
            contiguous<
                sequence<
                    ParserT,
                    negated_empty_match_parser<
                        TailT
                    >
                >
            >
                type;
    };
    distinct_directive()
    : tail(chset<CharT>())
    {
    }
    explicit distinct_directive(CharT const* letters)
    : tail(chset_p(letters))
    {
    }
    explicit distinct_directive(parser<TailT> const & tail_)
    : tail(tail_.derived())
    {
    }
    template<typename ParserT>
    typename result<typename as_parser<ParserT>::type>::type
        operator[](ParserT const &subject) const
    {
        return
            lexeme_d[as_parser<ParserT>::convert(subject) >> ~epsilon_p(tail)];
    }
    TailT tail;
};
template <typename ScannerT = scanner<> >
class dynamic_distinct_parser
{
public:
    typedef typename ScannerT::value_t char_t;
    typedef
        rule<typename lexeme_scanner<ScannerT>::type>
            tail_t;
    typedef
        contiguous<
            sequence<
                chseq<char_t const*>,
                negated_empty_match_parser<
                    tail_t
                >
            >
        >
            result_t;
    dynamic_distinct_parser()
    : tail(nothing_p)
    {
    }
    template<typename ParserT>
    explicit dynamic_distinct_parser(parser<ParserT> const & tail_)
    : tail(tail_.derived())
    {
    }
    explicit dynamic_distinct_parser(char_t const* letters)
    : tail(chset_p(letters))
    {
    }
    result_t operator()(char_t const* str) const
    {
        return lexeme_d[chseq_p(str) >> ~epsilon_p(tail)];
    }
    tail_t tail;
};
template <typename ScannerT = scanner<> >
class dynamic_distinct_directive
{
public:
    typedef typename ScannerT::value_t char_t;
    typedef
        rule<typename lexeme_scanner<ScannerT>::type>
            tail_t;
    template<typename ParserT>
    struct result {
        typedef
            contiguous<
                sequence<
                    ParserT,
                    negated_empty_match_parser<
                        tail_t
                    >
                >
            >
                type;
    };
    dynamic_distinct_directive()
    : tail(nothing_p)
    {
    }
    template<typename ParserT>
    explicit dynamic_distinct_directive(parser<ParserT> const & tail_)
    : tail(tail_.derived())
    {
    }
    explicit dynamic_distinct_directive(char_t const* letters)
    : tail(chset_p(letters))
    {
    }
    template<typename ParserT>
    typename result<typename as_parser<ParserT>::type>::type
        operator[](ParserT const &subject) const
    {
        return
            lexeme_d[as_parser<ParserT>::convert(subject) >> ~epsilon_p(tail)];
    }
    tail_t tail;
};
    }
}
#include <deque>
namespace boost
{
  namespace detail {
   template <class Category, class T, class Distance, class Pointer, class Reference>
   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
  }
  template <class Category, class T, class Distance = std::ptrdiff_t,
            class Pointer = T*, class Reference = T&>
   struct iterator : detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
}
namespace boost {
namespace mpl {
template<
      typename C = void_
    , typename F1 = void_
    , typename F2 = void_
    >
struct apply_if
{
 private:
    typedef typename if_<C,F1,F2>::type nullary_func_;
 public:
    typedef typename nullary_func_::type type;
   
};
template<
      bool C
    , typename F1
    , typename F2
    >
struct apply_if_c
{
 private:
    typedef typename if_c<C,F1,F2>::type nullary_func_;
 public:
    typedef typename nullary_func_::type type;
};
template<> struct apply_if< void_,void_,void_ > { template< typename T1,typename T2,typename T3 , typename T4 =void_ ,typename T5 =void_ > struct apply : apply_if< T1,T2,T3 > { }; }; template<> struct lambda< apply_if< void_,void_,void_ > , void_ , int_<-1> > { typedef apply_if< void_,void_,void_ > type; }; namespace aux { template< typename T1,typename T2,typename T3 > struct template_arity< apply_if< T1,T2,T3 > > { static const int value = 3; }; template<> struct template_arity< apply_if< void_,void_,void_ > > { static const int value = -1; }; }
}
}
namespace boost {
namespace mpl {
template<
      typename T = void_
    >
struct identity
{
    typedef T type;
   
};
template<
      typename T = void_
    >
struct make_identity
{
    typedef identity<T> type;
   
};
template<> struct identity< void_ > { template< typename T1 , typename T2 =void_ ,typename T3 =void_ ,typename T4 =void_ ,typename T5 =void_ > struct apply : identity< T1 > { }; }; template<> struct lambda< identity< void_ > , void_ , int_<-1> > { typedef identity< void_ > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > { static const int value = 1; }; template<> struct template_arity< identity< void_ > > { static const int value = -1; }; }
template<> struct make_identity< void_ > { template< typename T1 , typename T2 =void_ ,typename T3 =void_ ,typename T4 =void_ ,typename T5 =void_ > struct apply : make_identity< T1 > { }; }; template<> struct lambda< make_identity< void_ > , void_ , int_<-1> > { typedef make_identity< void_ > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > { static const int value = 1; }; template<> struct template_arity< make_identity< void_ > > { static const int value = -1; }; }
}
}
namespace boost {
namespace mpl {
template<> struct arg<-1>
{
    static int const value = -1;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U1 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_22;
    };
};
template<> struct arg<1>
{
    static int const value = 1;
    typedef arg<2> next;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U1 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_43;
    };
};
template<> struct arg<2>
{
    static int const value = 2;
    typedef arg<3> next;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U2 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_64;
    };
};
template<> struct arg<3>
{
    static int const value = 3;
    typedef arg<4> next;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U3 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_85;
    };
};
template<> struct arg<4>
{
    static int const value = 4;
    typedef arg<5> next;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U4 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_106;
    };
};
template<> struct arg<5>
{
    static int const value = 5;
    typedef arg<6> next;
   
    template<
          typename U1 = void_, typename U2 = void_, typename U3 = void_
        , typename U4 = void_, typename U5 = void_
        >
    struct apply
    {
        typedef U5 type;
     private:
        static bool const nv = !is_void_<type>::value;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( nv ) >)> boost_static_assert_typedef_127;
    };
};
}
}
namespace boost {
namespace mpl {
typedef arg< -1 > _;
namespace placeholders {
using boost::mpl::_;
}
typedef arg<1> _1;
namespace placeholders {
using boost::mpl::_1;
}
typedef arg<2> _2;
namespace placeholders {
using boost::mpl::_2;
}
typedef arg<3> _3;
namespace placeholders {
using boost::mpl::_3;
}
typedef arg<4> _4;
namespace placeholders {
using boost::mpl::_4;
}
typedef arg<5> _5;
namespace placeholders {
using boost::mpl::_5;
}
typedef arg<6> _6;
namespace placeholders {
using boost::mpl::_6;
}
}
}
namespace boost {
struct no_traversal_tag {};
struct incrementable_traversal_tag {};
struct single_pass_traversal_tag
  : incrementable_traversal_tag {};
struct forward_traversal_tag
  : single_pass_traversal_tag {};
struct bidirectional_traversal_tag
  : forward_traversal_tag {};
struct random_access_traversal_tag
  : bidirectional_traversal_tag {};
namespace detail
{
  template <class Cat>
  struct old_category_to_traversal
    : mpl::apply_if<
          is_convertible<Cat,std::random_access_iterator_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::apply_if<
              is_convertible<Cat,std::bidirectional_iterator_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::apply_if<
                  is_convertible<Cat,std::forward_iterator_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::apply_if<
                      is_convertible<Cat,std::input_iterator_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::apply_if<
                          is_convertible<Cat,std::output_iterator_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {};
  template <class Traversal>
  struct pure_traversal_tag
    : mpl::apply_if<
          is_convertible<Traversal,random_access_traversal_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::apply_if<
              is_convertible<Traversal,bidirectional_traversal_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::apply_if<
                  is_convertible<Traversal,forward_traversal_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::apply_if<
                      is_convertible<Traversal,single_pass_traversal_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::apply_if<
                          is_convertible<Traversal,incrementable_traversal_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {
  };
}
template <class Cat>
struct iterator_category_to_traversal
  : mpl::apply_if<
        is_convertible<Cat,incrementable_traversal_tag>
      , mpl::identity<Cat>
      , detail::old_category_to_traversal<Cat>
    >
{};
template <class Iterator = mpl::_1>
struct iterator_traversal
  : iterator_category_to_traversal<
        typename boost::detail::iterator_traits<Iterator>::iterator_category
    >
{};
}
namespace boost { namespace mpl {
namespace aux {
template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct or_impl
    : true_
{
};
template< typename T1, typename T2, typename T3, typename T4 >
struct or_impl< false,T1,T2,T3,T4 >
    : or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , false_
        >
{
};
template<>
struct or_impl<
          false
        , false_, false_, false_, false_
        >
    : false_
{
};
}
template<
      typename T1 = void_
    , typename T2 = void_
    , typename T3 = false_, typename T4 = false_, typename T5 = false_
    >
struct or_
    : aux::or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >
{
   
};
template<> struct or_< void_,void_ > { template< typename T1,typename T2 , typename T3 =void_ ,typename T4 =void_ ,typename T5 =void_ > struct apply : or_< T1,T2 > { }; }; template<> struct lambda< or_< void_,void_ > , void_ , int_<-1> > { typedef or_< void_,void_ > type; }; namespace aux { template< typename T1,typename T2,typename T3,typename T4,typename T5 > struct template_arity< or_< T1,T2,T3,T4,T5 > > { static const int value = 5; }; template<> struct template_arity< or_< void_,void_ > > { static const int value = -1; }; }
}}
namespace boost
{
  template <typename A, typename B>
  struct is_interoperable
    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >
  {
  };
}
namespace boost { namespace mpl {
namespace aux {
template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct and_impl
    : false_
{
};
template< typename T1, typename T2, typename T3, typename T4 >
struct and_impl< true,T1,T2,T3,T4 >
    : and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , true_
        >
{
};
template<>
struct and_impl<
          true
        , true_, true_, true_, true_
        >
    : true_
{
};
}
template<
      typename T1 = void_
    , typename T2 = void_
    , typename T3 = true_, typename T4 = true_, typename T5 = true_
    >
struct and_
    : aux::and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >
{
   
};
template<> struct and_< void_,void_ > { template< typename T1,typename T2 , typename T3 =void_ ,typename T4 =void_ ,typename T5 =void_ > struct apply : and_< T1,T2 > { }; }; template<> struct lambda< and_< void_,void_ > , void_ , int_<-1> > { typedef and_< void_,void_ > type; }; namespace aux { template< typename T1,typename T2,typename T3,typename T4,typename T5 > struct template_arity< and_< T1,T2,T3,T4,T5 > > { static const int value = 5; }; template<> struct template_arity< and_< void_,void_ > > { static const int value = -1; }; }
}}
namespace boost { struct use_default; }
namespace boost { namespace detail {
struct input_output_iterator_tag
  : std::input_iterator_tag
{
    operator std::output_iterator_tag() const
    {
        return std::output_iterator_tag();
    }
};
template <class ValueParam, class Reference>
struct iterator_writability_disabled
  : is_const<ValueParam>
{};
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
  : mpl::apply_if<
        mpl::and_<
            is_reference<Reference>
          , is_convertible<Traversal,forward_traversal_tag>
        >
      , mpl::apply_if<
            is_convertible<Traversal,random_access_traversal_tag>
          , mpl::identity<std::random_access_iterator_tag>
          , mpl::if_<
                is_convertible<Traversal,bidirectional_traversal_tag>
              , std::bidirectional_iterator_tag
              , std::forward_iterator_tag
            >
        >
      , typename mpl::apply_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>
              , is_convertible<Reference, ValueParam>
            >
          , mpl::identity<std::input_iterator_tag>
          , mpl::identity<Traversal>
        >
    >
{
};
template <class T>
struct is_iterator_category
  : mpl::or_<
        is_convertible<T,std::input_iterator_tag>
      , is_convertible<T,std::output_iterator_tag>
    >
{
};
template <class T>
struct is_iterator_traversal
  : is_convertible<T,incrementable_traversal_tag>
{};
template <class Category, class Traversal>
struct iterator_category_with_traversal
  : Category, Traversal
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( !(is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >::value) ) >)> boost_static_assert_typedef_158;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( is_iterator_category<Category>::value ) >)> boost_static_assert_typedef_160;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( !is_iterator_category<Traversal>::value ) >)> boost_static_assert_typedef_161;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( !is_iterator_traversal<Category>::value ) >)> boost_static_assert_typedef_162;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( is_iterator_traversal<Traversal>::value ) >)> boost_static_assert_typedef_164;
};
template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( !is_iterator_category<Traversal>::value ) >)> boost_static_assert_typedef_175;
    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;
    typedef typename mpl::if_<
        is_same<
            Traversal
          , typename iterator_category_to_traversal<category>::type
        >
      , category
      , iterator_category_with_traversal<category,Traversal>
    >::type type;
};
template <class CategoryOrTraversal, class ValueParam, class Reference>
struct facade_iterator_category
  : mpl::apply_if<
        is_iterator_category<CategoryOrTraversal>
      , mpl::identity<CategoryOrTraversal>
      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
    >
{
};
}}
namespace boost
{
  namespace iterators
  {
    template<bool>
    struct enabled
    {
      template<typename T>
      struct base
      {
        typedef T type;
      };
    };
    template<>
    struct enabled<false>
    {
      template<typename T>
      struct base
      {
      };
    };
    template <class Cond,
              class Return>
    struct enable_if
      : enabled<(Cond::value)>::template base<Return>
    {
    };
  }
}
namespace boost {
namespace detail {
template <typename T>
struct add_pointer_impl
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};
}
template< typename T > struct add_pointer { typedef typename detail::add_pointer_impl<T>::type type; };
}
namespace boost {
namespace detail {
template <typename T, bool is_vol>
struct remove_const_helper
{
    typedef T type;
};
template <typename T>
struct remove_const_helper<T, true>
{
    typedef T volatile type;
};
template <typename T>
struct remove_const_impl
{
    typedef typename remove_const_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_volatile<T>::value
        >::type type;
};
}
template< typename T > struct remove_const { typedef typename detail::remove_const_impl<T>::type type; };
template< typename T > struct remove_const<T&> { typedef T& type; };
template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };
}
namespace boost
{
  template <class I, class V, class TC, class R, class D> class iterator_facade;
  namespace detail
  {
    template <
        class Facade1
      , class Facade2
      , class Return
    >
    struct enable_if_interoperable
      : ::boost::iterators::enable_if<
           mpl::or_<
               is_convertible<Facade1, Facade2>
             , is_convertible<Facade2, Facade1>
           >
         , Return
        >
    {
    };
    template <
        class ValueParam
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    struct iterator_facade_types
    {
        typedef typename facade_iterator_category<
            CategoryOrTraversal, ValueParam, Reference
        >::type iterator_category;
        typedef typename remove_const<ValueParam>::type value_type;
        typedef typename mpl::apply_if<
            detail::iterator_writability_disabled<ValueParam,Reference>
          , add_pointer<typename add_const<value_type>::type>
          , add_pointer<value_type>
        >::type pointer;
    };
    template <class T>
    struct operator_arrow_proxy
    {
        operator_arrow_proxy(T const* px) : m_value(*px) {}
        const T* operator->() const { return &m_value; }
        operator const T*() const { return &m_value; }
        T m_value;
    };
    template <class Value, class Reference, class Pointer>
    struct operator_arrow_result
    {
        typedef typename mpl::if_<
            is_reference<Reference>
          , Pointer
          , operator_arrow_proxy<Value>
        >::type type;
        static type make(Reference x)
        {
            return type(&x);
        }
    };
    template <class Iterator>
    class operator_brackets_proxy
    {
        typedef typename Iterator::reference reference;
        typedef typename Iterator::value_type value_type;
     public:
        operator_brackets_proxy(Iterator const& iter)
          : m_iter(iter)
        {}
        operator reference() const
        {
            return *m_iter;
        }
        operator_brackets_proxy& operator=(value_type const& val)
        {
            *m_iter = val;
            return *this;
        }
     private:
        Iterator m_iter;
    };
    template <class Value, class Reference>
    struct use_operator_brackets_proxy
      : mpl::and_<
            boost::is_POD<Value>
          , iterator_writability_disabled<Value,Reference>
        >
    {};
    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
        typedef typename mpl::if_<
            use_operator_brackets_proxy<Value,Reference>
          , Value
          , operator_brackets_proxy<Iterator>
        >::type type;
    };
    template <class Iterator>
    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::false_)
    {
        return operator_brackets_proxy<Iterator>(iter);
    }
    template <class Iterator>
    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::true_)
    {
      return *iter;
    }
  }
  class iterator_core_access
  {
      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator ==( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator !=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator <( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator >( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator <=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator >=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs);
      template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > friend typename detail::enable_if_interoperable< Derived1, Derived2, typename Derived1::difference_type >::type operator -( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs)
      ;
      template <class Derived, class V, class TC, class R, class D> friend Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)
      ;
      template <class Derived, class V, class TC, class R, class D> friend Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)
      ;
      template <class Facade>
      static typename Facade::reference dereference(Facade const& f)
      {
          return f.dereference();
      }
      template <class Facade>
      static void increment(Facade& f)
      {
          f.increment();
      }
      template <class Facade>
      static void decrement(Facade& f)
      {
          f.decrement();
      }
      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2)
      {
          return f1.equal(f2);
      }
      template <class Facade>
      static void advance(Facade& f, typename Facade::difference_type n)
      {
          f.advance(n);
      }
      template <class Facade1, class Facade2>
      static typename Facade1::difference_type distance_to(
                                                           Facade1 const& f1, Facade2 const& f2)
      {
          return f1.distance_to(f2);
      }
   private:
      iterator_core_access();
  };
  template <
      class Derived
    , class Value
    , class CategoryOrTraversal
    , class Reference = Value&
    , class Difference = std::ptrdiff_t
  >
  class iterator_facade
  {
   private:
      typedef Derived derived_t;
      Derived& derived()
      {
          return static_cast<Derived&>(*this);
      }
      Derived const& derived() const
      {
          return static_cast<Derived const&>(*this);
      }
      typedef detail::iterator_facade_types<
         Value, CategoryOrTraversal, Reference, Difference
      > associated_types;
   public:
      typedef typename associated_types::value_type value_type;
      typedef Reference reference;
      typedef Difference difference_type;
      typedef typename associated_types::pointer pointer;
      typedef typename associated_types::iterator_category iterator_category;
      reference operator*() const
      {
          return iterator_core_access::dereference(this->derived());
      }
      typename detail::operator_arrow_result<
          value_type
        , reference
        , pointer
      >::type
      operator->() const
      {
          return detail::operator_arrow_result<
              value_type
            , reference
            , pointer
          >::make(*this->derived());
      }
      typename detail::operator_brackets_result<Derived,Value,Reference>::type
      operator[](difference_type n) const
      {
          typedef detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
          return detail::make_operator_brackets_result<Derived>(
              this->derived() + n
            , use_proxy()
          );
      }
      Derived& operator++()
      {
          iterator_core_access::increment(this->derived());
          return this->derived();
      }
      Derived operator++(int)
      {
          Derived tmp(this->derived());
          ++*this;
          return tmp;
      }
      Derived& operator--()
      {
          iterator_core_access::decrement(this->derived());
          return this->derived();
      }
      Derived operator--(int)
      {
          Derived tmp(this->derived());
          --*this;
          return tmp;
      }
      Derived& operator+=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), n);
          return this->derived();
      }
      Derived& operator-=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), -n);
          return this->derived();
      }
      Derived operator-(difference_type x) const
      {
          Derived result(this->derived());
          return result -= x;
      }
  };
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator ==( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_555; return iterator_core_access::equal( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator !=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_556; return ! iterator_core_access::equal( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator <( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_558; return 0 > iterator_core_access::distance_to( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator >( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_559; return 0 < iterator_core_access::distance_to( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator <=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_560; return 0 >= iterator_core_access::distance_to( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, bool >::type operator >=( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && true ) ) >)> boost_static_assert_typedef_561; return 0 <= iterator_core_access::distance_to( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
  template < class Derived1, class V1, class TC1, class R1, class D1 , class Derived2, class V2, class TC2, class R2, class D2 > inline typename detail::enable_if_interoperable< Derived1, Derived2, typename Derived1::difference_type >::type operator -( iterator_facade<Derived1, V1, TC1, R1, D1> const& lhs , iterator_facade<Derived2, V2, TC2, R2, D2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( ( is_interoperable< Derived1, Derived2 >::value && (is_same< typename Derived1::difference_type , typename Derived2::difference_type >::value) ) ) >)> boost_static_assert_typedef_573; return iterator_core_access::distance_to( static_cast<Derived2 const&>(rhs), static_cast<Derived1 const&>(lhs)); }
template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
}
namespace boost {
template <class Iterator>
struct iterator_value
{
    typedef typename detail::iterator_traits<Iterator>::value_type type;
};
template <class Iterator>
struct iterator_reference
{
    typedef typename detail::iterator_traits<Iterator>::reference type;
};
template <class Iterator>
struct iterator_pointer
{
    typedef typename detail::iterator_traits<Iterator>::pointer type;
};
template <class Iterator>
struct iterator_difference
{
    typedef typename detail::iterator_traits<Iterator>::difference_type type;
};
template <class Iterator>
struct iterator_category
{
    typedef typename detail::iterator_traits<Iterator>::iterator_category type;
};
}
namespace boost
{
  struct use_default;
  template<class To>
  struct is_convertible<use_default,To>
    : mpl::false_ {};
  namespace detail
  {
    struct enable_type;
  }
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
        , detail::enable_type
      >
  {};
  namespace detail
  {
    template <class T, class DefaultNullaryFn>
    struct ia_dflt_help
      : mpl::apply_if<
            is_same<T, use_default>
          , DefaultNullaryFn
          , mpl::identity<T>
        >
    {
    };
    template <
        class Derived
      , class Base
      , class Value
      , class Traversal
      , class Reference
      , class Difference
    >
    struct iterator_adaptor_base
    {
        typedef iterator_facade<
            Derived
          , typename detail::ia_dflt_help<
                Value, iterator_value<Base>
            >::type
          , typename detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type
          , typename detail::ia_dflt_help<
                Reference
              , mpl::apply_if<
                    is_same<Value,use_default>
                  , iterator_reference<Base>
                  , add_reference<Value>
                >
            >::type
          , typename detail::ia_dflt_help<
                Difference, iterator_difference<Base>
            >::type
        >
        type;
    };
    template <class T> int static_assert_convertible_to(T);
  }
  template <
      class Derived
    , class Base
    , class Value = use_default
    , class Traversal = use_default
    , class Reference = use_default
    , class Difference = use_default
  >
  class iterator_adaptor
    : public detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;
      typedef typename detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
      iterator_adaptor() {}
      explicit iterator_adaptor(Base const &iter)
          : m_iterator(iter)
      {
      }
      Base base() const
        { return m_iterator; }
   protected:
      Base const& base_reference() const
        { return m_iterator; }
      Base& base_reference()
        { return m_iterator; }
   private:
      typename super_t::reference dereference() const
        { return *m_iterator; }
      template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
      {
          return m_iterator == x.base();
      }
      typedef typename iterator_category_to_traversal<
          typename super_t::iterator_category
      >::type my_traversal;
      void advance(typename super_t::difference_type n)
      {
          typedef int assertion[sizeof(detail::static_assert_convertible_to<random_access_traversal_tag>(my_traversal()))];
          m_iterator += n;
      }
      void increment() { ++m_iterator; }
      void decrement()
      {
          typedef int assertion[sizeof(detail::static_assert_convertible_to<bidirectional_traversal_tag>(my_traversal()))];
           --m_iterator;
      }
      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      typename super_t::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
      {
          typedef int assertion[sizeof(detail::static_assert_convertible_to<random_access_traversal_tag>(my_traversal()))];
          return y.base() - m_iterator;
      }
   private:
      Base m_iterator;
  };
}
namespace boost { namespace spirit {
namespace impl {
template <typename QueueT, typename T, typename PointerT>
class fsq_iterator
: public boost::iterator_adaptor<
        fsq_iterator<QueueT, T, PointerT>,
        PointerT,
        T,
        std::random_access_iterator_tag
    >
{
public:
    typedef typename QueueT::position_t position;
    typedef boost::iterator_adaptor<
            fsq_iterator<QueueT, T, PointerT>, PointerT, T,
            std::random_access_iterator_tag
        > base_t;
    fsq_iterator() {}
    fsq_iterator(position const &p_) : p(p_) {}
    position const &get_position() const { return p; }
private:
    friend class boost::iterator_core_access;
    typename base_t::reference dereference() const
    {
        return p.self->m_queue[p.pos];
    }
    void increment()
    {
        ++p.pos;
        if (p.pos == QueueT::MAX_SIZE+1)
            p.pos = 0;
    }
    void decrement()
    {
        if (p.pos == 0)
            p.pos = QueueT::MAX_SIZE;
        else
            --p.pos;
    }
    template <
        typename OtherDerivedT, typename OtherIteratorT,
        typename V, typename C, typename R, typename D
    >
    bool equal(iterator_adaptor<OtherDerivedT, OtherIteratorT, V, C, R, D>
        const &x) const
    {
        position const &rhs_pos =
            static_cast<OtherDerivedT const &>(x).get_position();
        return (p.self == rhs_pos.self) && (p.pos == rhs_pos.pos);
    }
    template <
        typename OtherDerivedT, typename OtherIteratorT,
        typename V, typename C, typename R, typename D
    >
    typename base_t::difference_type distance_to(
        iterator_adaptor<OtherDerivedT, OtherIteratorT, V, C, R, D>
        const &x) const
    {
        typedef typename base_t::difference_type diff_t;
        position const &p2 =
            static_cast<OtherDerivedT const &>(x).get_position();
        std::size_t pos1 = p.pos;
        std::size_t pos2 = p2.pos;
        ;
        if (pos1 < p.self->m_head)
            pos1 += QueueT::MAX_SIZE;
        if (pos2 < p2.self->m_head)
            pos2 += QueueT::MAX_SIZE;
        if (pos2 > pos1)
            return diff_t(pos2 - pos1);
        else
            return -diff_t(pos1 - pos2);
    }
    void advance(typename base_t::difference_type n)
    {
        if (n < 0)
        {
            n = -n;
            if (p.pos < (std::size_t)n)
                p.pos = QueueT::MAX_SIZE+1 - (n - p.pos);
            else
                p.pos -= n;
        }
        else
        {
            p.pos += n;
            if (p.pos >= QueueT::MAX_SIZE+1)
                p.pos -= QueueT::MAX_SIZE+1;
        }
    }
private:
    position p;
};
}
template <typename T, std::size_t N>
class fixed_size_queue
{
private:
    struct position
    {
        fixed_size_queue* self;
        std::size_t pos;
        position() : self(0), pos(0) {}
        position(const fixed_size_queue* s, std::size_t p)
            : self(const_cast<fixed_size_queue*>(s)), pos(p)
        {}
    };
public:
    typedef impl::fsq_iterator<fixed_size_queue<T, N>, T, T*> iterator;
    typedef impl::fsq_iterator<fixed_size_queue<T, N>, T const, T const*>
        const_iterator;
    typedef position position_t;
    friend class impl::fsq_iterator<fixed_size_queue<T, N>, T, T*>;
    friend class impl::fsq_iterator<fixed_size_queue<T, N>, T const, T const*>;
    fixed_size_queue();
    fixed_size_queue(const fixed_size_queue& x);
    fixed_size_queue& operator=(const fixed_size_queue& x);
    ~fixed_size_queue();
    void push_back(const T& e);
    void push_front(const T& e);
    void serve(T& e);
    void pop_front();
    bool empty() const
    {
        return m_size == 0;
    }
    bool full() const
    {
        return m_size == N;
    }
    iterator begin()
    {
        return iterator(position(this, m_head));
    }
    const_iterator begin() const
    {
        return const_iterator(position(this, m_head));
    }
    iterator end()
    {
        return iterator(position(this, m_tail));
    }
    const_iterator end() const
    {
        return const_iterator(position(this, m_tail));
    }
    std::size_t size() const
    {
        return m_size;
    }
    T& front()
    {
        return m_queue[m_head];
    }
    const T& front() const
    {
        return m_queue[m_head];
    }
private:
    static const std::size_t MAX_SIZE = N;
    std::size_t m_head;
    std::size_t m_tail;
    std::size_t m_size;
    T m_queue[N+1];
};
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::fixed_size_queue()
    : m_head(0)
    , m_tail(0)
    , m_size(0)
{
    ;
    ;
    ;
    ;
}
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::fixed_size_queue(const fixed_size_queue& x)
    : m_head(x.m_head)
    , m_tail(x.m_tail)
    , m_size(x.m_size)
{
    copy(x.begin(), x.end(), begin());
    ;
    ;
    ;
    ;
}
template <typename T, std::size_t N>
inline fixed_size_queue<T, N>&
fixed_size_queue<T, N>::operator=(const fixed_size_queue& x)
{
    if (this != &x)
    {
        m_head = x.m_head;
        m_tail = x.m_tail;
        m_size = x.m_size;
        copy(x.begin(), x.end(), begin());
    }
    ;
    ;
    ;
    ;
    return *this;
}
template <typename T, std::size_t N>
inline
fixed_size_queue<T, N>::~fixed_size_queue()
{
    ;
    ;
    ;
    ;
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::push_back(const T& e)
{
    ;
    ;
    ;
    ;
    ;
    m_queue[m_tail] = e;
    ++m_size;
    ++m_tail;
    if (m_tail == N+1)
        m_tail = 0;
    ;
    ;
    ;
    ;
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::push_front(const T& e)
{
    ;
    ;
    ;
    ;
    ;
    if (m_head == 0)
        m_head = N;
    else
        --m_head;
    m_queue[m_head] = e;
    ++m_size;
    ;
    ;
    ;
    ;
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::serve(T& e)
{
    ;
    ;
    ;
    ;
    e = m_queue[m_head];
    pop_front();
}
template <typename T, std::size_t N>
inline void
fixed_size_queue<T, N>::pop_front()
{
    ;
    ;
    ;
    ;
    ++m_head;
    if (m_head == N+1)
        m_head = 0;
    --m_size;
    ;
    ;
    ;
    ;
}
}}
namespace boost { namespace spirit {
namespace impl {
    template <typename T>
    inline void mp_swap(T& t1, T& t2);
}
namespace multi_pass_policies
{
class ref_counted
{
    protected:
        ref_counted()
            : count(new std::size_t(1))
        {}
        ref_counted(ref_counted const& x)
            : count(x.count)
        {}
        void clone()
        {
            ++*count;
        }
        bool release()
        {
            if (!--*count)
            {
                delete count;
                count = 0;
                return true;
            }
            return false;
        }
        void swap(ref_counted& x)
        {
            impl::mp_swap(count, x.count);
        }
    public:
        bool unique() const
        {
            return *count == 1;
        }
    private:
        std::size_t* count;
};
class first_owner
{
    protected:
        first_owner()
            : first(true)
        {}
        first_owner(first_owner const&)
            : first(false)
        {}
        void clone()
        {
        }
        bool release()
        {
            return first;
        }
        void swap(first_owner&)
        {
        }
    public:
        bool unique() const
        {
            return false;
        }
    private:
        bool first;
};
class illegal_backtracking : public std::exception
{
public:
    illegal_backtracking() throw() {}
    ~illegal_backtracking() throw() {}
    virtual const char*
    what() const throw()
    { return "boost::spirit::illegal_backtracking"; }
};
class buf_id_check
{
    protected:
        buf_id_check()
            : shared_buf_id(new unsigned long(0))
            , buf_id(0)
        {}
        buf_id_check(buf_id_check const& x)
            : shared_buf_id(x.shared_buf_id)
            , buf_id(x.buf_id)
        {}
        void destroy()
        {
            delete shared_buf_id;
            shared_buf_id = 0;
        }
        void swap(buf_id_check& x)
        {
            impl::mp_swap(shared_buf_id, x.shared_buf_id);
            impl::mp_swap(buf_id, x.buf_id);
        }
        void check() const
        {
            if (buf_id != *shared_buf_id)
            {
                boost::throw_exception(illegal_backtracking());
            }
        }
        void clear_queue()
        {
            ++*shared_buf_id;
            ++buf_id;
        }
    private:
        unsigned long* shared_buf_id;
        unsigned long buf_id;
};
class no_check
{
    protected:
        no_check() {}
        no_check(no_check const&) {}
        void destroy() {}
        void swap(no_check&) {}
        void check() const {}
        void clear_queue() {}
};
class std_deque
{
    public:
template <typename ValueT>
class inner
{
    private:
        typedef std::deque<ValueT> queue_type;
        queue_type* queuedElements;
        mutable typename queue_type::size_type queuePosition;
    protected:
        inner()
            : queuedElements(new queue_type)
            , queuePosition(0)
        {}
        inner(inner const& x)
            : queuedElements(x.queuedElements)
            , queuePosition(x.queuePosition)
        {}
        void destroy()
        {
            ;
            delete queuedElements;
            queuedElements = 0;
        }
        void swap(inner& x)
        {
            impl::mp_swap(queuedElements, x.queuedElements);
            impl::mp_swap(queuePosition, x.queuePosition);
        }
        template <typename MultiPassT>
        static typename MultiPassT::reference dereference(MultiPassT const& mp)
        {
            if (mp.queuePosition == mp.queuedElements->size())
            {
                if (mp.unique())
                {
                    if (mp.queuedElements->size() > 0)
                    {
                        mp.queuedElements->clear();
                        mp.queuePosition = 0;
                    }
                }
                return mp.get_input();
            }
            else
            {
                return (*mp.queuedElements)[mp.queuePosition];
            }
        }
        template <typename MultiPassT>
        static void increment(MultiPassT& mp)
        {
            if (mp.queuePosition == mp.queuedElements->size())
            {
                if (mp.unique())
                {
                    if (mp.queuedElements->size() > 0)
                    {
                        mp.queuedElements->clear();
                        mp.queuePosition = 0;
                    }
                }
                else
                {
                    mp.queuedElements->push_back(mp.get_input());
                    ++mp.queuePosition;
                }
                mp.advance_input();
            }
            else
            {
                ++mp.queuePosition;
            }
        }
        void clear_queue()
        {
            queuedElements->clear();
            queuePosition = 0;
        }
        template <typename MultiPassT>
        static bool is_eof(MultiPassT const& mp)
        {
            return mp.queuePosition == mp.queuedElements->size() &&
                mp.input_at_eof();
        }
        bool equal_to(inner const& x) const
        {
            return queuePosition == x.queuePosition;
        }
        bool less_than(inner const& x) const
        {
            return queuePosition < x.queuePosition;
        }
};
};
template < std::size_t N>
class fixed_size_queue
{
    public:
template <typename ValueT>
class inner
{
    private:
        typedef boost::spirit::fixed_size_queue<ValueT, N> queue_type;
        queue_type * queuedElements;
        mutable typename queue_type::iterator queuePosition;
    protected:
        inner()
            : queuedElements(new queue_type)
            , queuePosition(queuedElements->begin())
        {}
        inner(inner const& x)
            : queuedElements(x.queuedElements)
            , queuePosition(x.queuePosition)
        {}
        void destroy()
        {
            ;
            delete queuedElements;
            queuedElements = 0;
        }
        void swap(inner& x)
        {
            impl::mp_swap(queuedElements, x.queuedElements);
            impl::mp_swap(queuePosition, x.queuePosition);
        }
        template <typename MultiPassT>
        static typename MultiPassT::reference dereference(MultiPassT const& mp)
        {
            if (mp.queuePosition == mp.queuedElements->end())
            {
                return mp.get_input();
            }
            else
            {
                return *mp.queuePosition;
            }
        }
        template <typename MultiPassT>
        static void increment(MultiPassT& mp)
        {
            if (mp.queuePosition == mp.queuedElements->end())
            {
                if (mp.queuedElements->size() >= N)
                    mp.queuedElements->pop_front();
                mp.queuedElements->push_back(mp.get_input());
                mp.advance_input();
            }
            ++mp.queuePosition;
        }
        void clear_queue()
        {}
        template <typename MultiPassT>
        static bool is_eof(MultiPassT const& mp)
        {
            return mp.queuePosition == mp.queuedElements->end() &&
                mp.input_at_eof();
        }
        bool equal_to(inner const& x) const
        {
            return queuePosition == x.queuePosition;
        }
        bool less_than(inner const& x) const
        {
            return queuePosition < x.queuePosition;
        }
};
};
class input_iterator
{
    public:
template <typename InputT>
class inner
{
    public:
        typedef
            typename boost::detail::iterator_traits<InputT>::value_type
            value_type;
        typedef
            typename boost::detail::iterator_traits<InputT>::difference_type
            difference_type;
        typedef
            typename boost::detail::iterator_traits<InputT>::pointer
            pointer;
        typedef
            typename boost::detail::iterator_traits<InputT>::reference
            reference;
    protected:
        inner()
            : input(new InputT())
            , val(new value_type)
        {}
        inner(InputT x)
            : input(new InputT(x))
            , val(new value_type(**input))
        {}
        inner(inner const& x)
            : input(x.input)
            , val(x.val)
        {}
        void destroy()
        {
            delete input;
            input = 0;
            delete val;
            val = 0;
        }
        bool same_input(inner const& x) const
        {
            return input == x.input;
        }
        typedef
            typename boost::detail::iterator_traits<InputT>::value_type
            value_t;
        void swap(inner& x)
        {
            impl::mp_swap(input, x.input);
            impl::mp_swap(val, x.val);
        }
    public:
        reference get_input() const
        {
            return *val;
        }
        void advance_input()
        {
            ++*input;
            *val = **input;
        }
        bool input_at_eof() const
        {
            return *input == InputT();
        }
    private:
        InputT* input;
        value_type* val;
};
};
class lex_input
{
    public:
template <typename InputT>
class inner
{
    public:
        typedef int value_type;
    typedef std::ptrdiff_t difference_type;
        typedef int* pointer;
        typedef int& reference;
    protected:
        inner()
            : curtok(new int(0))
        {}
        inner(InputT x)
            : curtok(new int(x))
        {}
        inner(inner const& x)
            : curtok(x.curtok)
        {}
        void destroy()
        {
            delete curtok;
            curtok = 0;
        }
        bool same_input(inner const& x) const
        {
            return curtok == x.curtok;
        }
        void swap(inner& x)
        {
            impl::mp_swap(curtok, x.curtok);
        }
    public:
        reference get_input() const
        {
            return *curtok;
        }
        void advance_input()
        {
            extern int yylex();
            *curtok = yylex();
        }
        bool input_at_eof() const
        {
            return *curtok == 0;
        }
    private:
        int* curtok;
};
};
class functor_input
{
    public:
template <typename FunctorT>
class inner
{
    typedef typename FunctorT::result_type result_type;
    public:
        typedef result_type value_type;
    typedef std::ptrdiff_t difference_type;
        typedef result_type* pointer;
        typedef result_type& reference;
    protected:
        inner()
            : ftor(0)
            , curtok(0)
        {}
        inner(FunctorT const& x)
            : ftor(new FunctorT(x))
            , curtok(new result_type((*ftor)()))
        {}
        inner(inner const& x)
            : ftor(x.ftor)
            , curtok(x.curtok)
        {}
        void destroy()
        {
            delete ftor;
            ftor = 0;
            delete curtok;
            curtok = 0;
        }
        bool same_input(inner const& x) const
        {
            return ftor == x.ftor;
        }
        void swap(inner& x)
        {
            impl::mp_swap(curtok, x.curtok);
            impl::mp_swap(ftor, x.ftor);
        }
    public:
        reference get_input() const
        {
            return *curtok;
        }
        void advance_input()
        {
            if (curtok) {
                *curtok = (*ftor)();
            }
        }
        bool input_at_eof() const
        {
            return !curtok || *curtok == ftor->eof;
        }
        FunctorT& get_functor() const
        {
            return *ftor;
        }
    private:
        FunctorT* ftor;
        result_type* curtok;
};
};
}
namespace iterator_ { namespace impl {
template <typename InputPolicyT, typename InputT>
struct iterator_base_creator
{
    typedef typename InputPolicyT::template inner<InputT> input_t;
    typedef boost::iterator
    <
        std::forward_iterator_tag,
        typename input_t::value_type,
        typename input_t::difference_type,
        typename input_t::pointer,
        typename input_t::reference
    > type;
};
}}
template
<
    typename InputT,
    typename InputPolicy = multi_pass_policies::input_iterator,
    typename OwnershipPolicy = multi_pass_policies::ref_counted,
    typename CheckingPolicy = multi_pass_policies::buf_id_check,
    typename StoragePolicy = multi_pass_policies::std_deque
>
class multi_pass;
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
class multi_pass
    : public OwnershipPolicy
    , public CheckingPolicy
    , public StoragePolicy::template inner<
                typename InputPolicy::template inner<InputT>::value_type>
    , public InputPolicy::template inner<InputT>
    , public iterator_::impl::iterator_base_creator<InputPolicy, InputT>::type
{
        typedef OwnershipPolicy OP;
        typedef CheckingPolicy CHP;
        typedef typename StoragePolicy::template inner<
            typename InputPolicy::template inner<InputT>::value_type> SP;
        typedef typename InputPolicy::template inner<InputT> IP;
        typedef typename
            iterator_::impl::iterator_base_creator<InputPolicy, InputT>::type
            IB;
    public:
        typedef typename IB::value_type value_type;
        typedef typename IB::difference_type difference_type;
        typedef typename IB::reference reference;
        typedef typename IB::pointer pointer;
        typedef InputT iterator_type;
        multi_pass();
        explicit multi_pass(InputT input);
        ~multi_pass();
        multi_pass(multi_pass const&);
        multi_pass& operator=(multi_pass const&);
        void swap(multi_pass& x);
        reference operator*() const;
        pointer operator->() const;
        multi_pass& operator++();
        multi_pass operator++(int);
        void clear_queue();
        bool operator==(const multi_pass& y) const;
        bool operator<(const multi_pass& y) const;
    private:
        bool is_eof() const;
};
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
multi_pass()
    : OP()
    , CHP()
    , SP()
    , IP()
{
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
multi_pass(InputT input)
    : OP()
    , CHP()
    , SP()
    , IP(input)
{
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
~multi_pass()
{
    if (OP::release())
    {
        CHP::destroy();
        SP::destroy();
        IP::destroy();
    }
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
multi_pass(
        multi_pass const& x)
    : OP(x)
    , CHP(x)
    , SP(x)
    , IP(x)
{
    OP::clone();
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>&
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator=(
        multi_pass const& x)
{
    multi_pass temp(x);
    temp.swap(*this);
    return *this;
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline void
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
swap(multi_pass& x)
{
    OP::swap(x);
    CHP::swap(x);
    SP::swap(x);
    IP::swap(x);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
typename multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
reference
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator*() const
{
    CHP::check();
    return SP::dereference(*this);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
typename multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
pointer
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator->() const
{
    return &(operator*());
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>&
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator++()
{
    CHP::check();
    SP::increment(*this);
    return *this;
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator++(int)
{
    multi_pass
    <
        InputT,
        InputPolicy,
        OwnershipPolicy,
        CheckingPolicy,
        StoragePolicy
    > tmp(*this);
    ++*this;
    return tmp;
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline void
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
clear_queue()
{
    SP::clear_queue();
    CHP::clear_queue();
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline bool
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
is_eof() const
{
    return SP::is_eof(*this);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline bool
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator==(const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
        StoragePolicy>& y) const
{
    if (is_eof() && y.is_eof())
    {
        return true;
    }
    else if (is_eof() ^ y.is_eof())
    {
        return false;
    }
    else if (!IP::same_input(y))
    {
        return false;
    }
    else
    {
        return SP::equal_to(y);
    }
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline bool
multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy>::
operator<(const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
        StoragePolicy>& y) const
{
    return SP::less_than(y);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
bool operator!=(
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& x,
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& y)
{
    return !(x == y);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
bool operator>(
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& x,
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& y)
{
    return y < x;
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
bool operator>=(
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& x,
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& y)
{
    return !(x < y);
}
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
inline
bool operator<=(
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& x,
        const multi_pass<InputT, InputPolicy, OwnershipPolicy, CheckingPolicy,
                        StoragePolicy>& y)
{
    return !(y < x);
}
template <typename InputT>
inline multi_pass<InputT>
make_multi_pass(InputT i)
{
    return multi_pass<InputT>(i);
}
template <typename InputT, std::size_t N>
class look_ahead :
    public multi_pass<
        InputT,
        multi_pass_policies::input_iterator,
        multi_pass_policies::first_owner,
        multi_pass_policies::no_check,
        multi_pass_policies::fixed_size_queue<N> >
{
        typedef multi_pass<
            InputT,
            multi_pass_policies::input_iterator,
            multi_pass_policies::first_owner,
            multi_pass_policies::no_check,
            multi_pass_policies::fixed_size_queue<N> > base_t;
    public:
        look_ahead()
            : base_t() {}
        explicit look_ahead(InputT x)
            : base_t(x) {}
        look_ahead(look_ahead const& x)
            : base_t(x) {}
};
template
<
    typename InputT,
    typename InputPolicy,
    typename OwnershipPolicy,
    typename CheckingPolicy,
    typename StoragePolicy
>
void swap(
    multi_pass<
        InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy
    > &x,
    multi_pass<
        InputT, InputPolicy, OwnershipPolicy, CheckingPolicy, StoragePolicy
    > &y)
{
    x.swap(y);
}
namespace impl {
    template <typename T>
    inline void mp_swap(T& t1, T& t2)
    {
        using std::swap;
        using boost::spirit::swap;
        swap(t1, t2);
    }
}
}}
namespace boost { namespace spirit {
    namespace impl {
        template <typename T>
        void flush_iterator(T &) {}
        template <typename T1, typename T2, typename T3, typename T4>
        void flush_iterator(boost::spirit::multi_pass<
            T1, T2, T3, T4, boost::spirit::multi_pass_policies::std_deque> &i)
        {
            i.clear_queue();
        }
    }
    class flush_multi_pass_parser
    : public parser<flush_multi_pass_parser>
    {
    public:
        typedef flush_multi_pass_parser this_t;
        template <typename ScannerT>
        typename parser_result<this_t, ScannerT>::type
        parse(ScannerT const& scan) const
        {
            impl::flush_iterator(scan.first);
            return scan.empty_match();
        }
    };
    flush_multi_pass_parser const
        flush_multi_pass_p = flush_multi_pass_parser();
}}
namespace boost { namespace spirit {
    template <typename MutexT, typename ParserT>
    struct scoped_lock_parser
        : public unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > >
    {
        typedef scoped_lock_parser<MutexT, ParserT> self_t;
        typedef MutexT mutex_t;
        typedef ParserT parser_t;
        template <typename ScannerT>
        struct result
        {
            typedef typename parser_result<parser_t, ScannerT>::type type;
        };
        scoped_lock_parser(mutex_t &m, parser_t const &p)
            : unary< ParserT, parser< scoped_lock_parser<MutexT, ParserT> > >(p)
            , mutex(m)
        {}
        template <typename ScannerT>
        typename parser_result<self_t, ScannerT>::type
        parse(ScannerT const &scan) const
        {
            typedef typename mutex_t::scoped_lock scoped_lock_t;
            scoped_lock_t lock(mutex);
            return this->subject().parse(scan);
        }
        mutex_t &mutex;
    };
    template <typename MutexT>
    struct scoped_lock_parser_gen
    {
        typedef MutexT mutex_t;
        explicit scoped_lock_parser_gen(mutex_t &m) : mutex(m) {}
        template<typename ParserT>
        scoped_lock_parser
        <
            MutexT,
            typename as_parser<ParserT>::type
        >
        operator[](ParserT const &p) const
        {
            typedef ::boost::spirit::as_parser<ParserT> as_parser_t;
            typedef typename as_parser_t::type parser_t;
            return scoped_lock_parser<mutex_t, parser_t>
                (mutex, as_parser_t::convert(p));
        }
        mutex_t &mutex;
    };
    template <typename MutexT>
    scoped_lock_parser_gen<MutexT>
    scoped_lock_d(MutexT &mutex)
    {
        return scoped_lock_parser_gen<MutexT>(mutex);
    }
}}
namespace boost { namespace spirit {
namespace impl
{
    template <typename CharT, typename T>
    class tst;
}
template <typename T, typename SetT>
class symbol_inserter;
template
<
    typename T = int,
    typename CharT = char,
    typename SetT = impl::tst<T, CharT>
>
class symbols
: private SetT
, public parser<symbols<T, CharT, SetT> >
{
public:
    typedef parser<symbols<T, CharT, SetT> > parser_base_t;
    typedef symbols<T, CharT, SetT> self_t;
    typedef self_t const& embed_t;
    typedef T symbol_data_t;
    typedef boost::reference_wrapper<T> symbol_ref_t;
    symbols();
    symbols(symbols const& other);
    ~symbols();
    symbols&
    operator=(symbols const& other);
    symbol_inserter<T, SetT> const&
    operator=(CharT const* str);
    template <typename ScannerT>
    struct result
    {
        typedef typename match_result<ScannerT, symbol_ref_t>::type type;
    };
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse_main(ScannerT const& scan) const
    {
        typedef typename ScannerT::iterator_t iterator_t;
        iterator_t first = scan.first;
        typename SetT::search_info result = SetT::find(scan);
        if (result.data)
            return scan.
                create_match(
                    result.length,
                    symbol_ref_t(*result.data),
                    first,
                    scan.first);
        else
            return scan.no_match();
    }
    template <typename ScannerT>
    typename parser_result<self_t, ScannerT>::type
    parse(ScannerT const& scan) const
    {
        typedef typename parser_result<self_t, ScannerT>::type result_t;
        return impl::implicit_lexeme_parse<result_t>
            (*this, scan, scan);
    }
    template < typename ScannerT >
    T* find(ScannerT const& scan) const
    { return SetT::find(scan).data; }
    symbol_inserter<T, SetT> const add;
};
template <typename T, typename CharT, typename SetT>
T* add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data = T());
template <typename T, typename CharT, typename SetT>
T* find(symbols<T, CharT, SetT> const& table, CharT const* sym);
template <typename T, typename SetT>
class symbol_inserter
{
public:
    symbol_inserter(SetT& set_)
    : set(set_) {}
    template <typename IteratorT>
    symbol_inserter const&
    operator()(IteratorT first, IteratorT const& last, T const& data = T()) const
    {
        set.add(first, last, data);
        return *this;
    }
    template <typename CharT>
    symbol_inserter const&
    operator()(CharT const* str, T const& data = T()) const
    {
        CharT const* last = str;
        while (*last)
            last++;
        set.add(str, last, data);
        return *this;
    }
    template <typename CharT>
    symbol_inserter const&
    operator,(CharT const* str) const
    {
        CharT const* last = str;
        while (*last)
            last++;
        set.add(str, last, T());
        return *this;
    }
private:
    SetT& set;
};
}}
namespace boost { namespace spirit {
    namespace impl
    {
    template <typename T, typename CharT>
    struct tst_node
    {
        tst_node(CharT value_)
        : value(value_)
        , left(0)
        , right(0)
        { middle.link = 0; }
        ~tst_node()
        {
            delete left;
            delete right;
            if (value)
                delete middle.link;
            else
                delete middle.data;
        }
        tst_node*
        clone() const
        {
            std::auto_ptr<tst_node> copy(new tst_node(value));
            if (left)
                copy->left = left->clone();
            if (right)
                copy->right = right->clone();
            if (value && middle.link)
            {
                copy->middle.link = middle.link->clone();
            }
            else
            {
                std::auto_ptr<T> mid_data(new T(*middle.data));
                copy->middle.data = mid_data.release();
            }
            return copy.release();
        }
        union center {
            tst_node* link;
            T* data;
        };
        CharT value;
        tst_node* left;
        center middle;
        tst_node* right;
    };
    template <typename T, typename CharT>
    class tst
    {
    public:
        struct search_info
        {
            T* data;
            std::size_t length;
        };
        tst()
        : root(0) {}
        tst(tst const& other)
        : root(other.root ? other.root->clone() : 0) {}
        ~tst()
        { delete root; }
        tst&
        operator=(tst const& other)
        {
            if (this != &other)
            {
                node_t* new_root = other.root ? other.root->clone() : 0;
                delete root;
                root = new_root;
            }
            return *this;
        }
        template <typename IteratorT>
        T* add(IteratorT first, IteratorT const& last, T const& data)
        {
            if (first == last)
                return 0;
            node_t** np = &root;
            CharT ch = *first;
            for (;;)
            {
                if (*np == 0 || ch == 0)
                {
                    node_t* right = 0;
                    if (np != 0)
                        right = *np;
                    *np = new node_t(ch);
                    if (right)
                        (**np).right = right;
                }
                if (ch < (**np).value)
                {
                    np = &(**np).left;
                }
                else
                {
                    if (ch == (**np).value)
                    {
                        if (ch == 0)
                        {
                            if ((**np).middle.data == 0)
                            {
                                (**np).middle.data = new T(data);
                                return (**np).middle.data;
                            }
                            else
                            {
                                return 0;
                            }
                       }
                        ++first;
                        ch = (first == last) ? 0 : *first;
                        np = &(**np).middle.link;
                    }
                    else
                    {
                        np = &(**np).right;
                    }
                }
            }
        }
        template <typename ScannerT>
        search_info find(ScannerT const& scan) const
        {
            search_info result = { 0, 0 };
            if (scan.at_end()) {
                return result;
            }
            typedef typename ScannerT::iterator_t iterator_t;
            node_t* np = root;
            CharT ch = *scan;
            iterator_t save = scan.first;
            iterator_t latest = scan.first;
            std::size_t latest_len = 0;
            while (np)
            {
                if (ch < np->value)
                {
                    if (np->value == 0)
                    {
                        result.data = np->middle.data;
                        if (result.data)
                        {
                            latest = scan.first;
                            latest_len = result.length;
                        }
                    }
                    np = np->left;
                }
                else
                {
                    if (ch == np->value)
                    {
                        if (scan.at_end())
                        {
                            result.data = np->middle.data;
                            if (result.data)
                            {
                                latest = scan.first;
                                latest_len = result.length;
                            }
                            break;
                        }
                        ++scan;
                        ch = scan.at_end() ? 0 : *scan;
                        np = np->middle.link;
                        ++result.length;
                    }
                    else
                    {
                        if (np->value == 0)
                        {
                            result.data = np->middle.data;
                            if (result.data)
                            {
                                latest = scan.first;
                                latest_len = result.length;
                            }
                        }
                        np = np->right;
                     }
                }
            }
            if (result.data == 0)
            {
                scan.first = save;
            }
            else
            {
                scan.first = latest;
                result.length = latest_len;
            }
            return result;
        }
    private:
        typedef tst_node<T, CharT> node_t;
        node_t* root;
    };
    }
}}
namespace boost { namespace spirit {
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>::symbols()
: SetT()
, add(*this)
{
}
template <typename T, typename CharT, typename SetT>
symbols<T, CharT, SetT>::symbols(symbols const& other)
: SetT(other)
, parser<symbols<T, CharT, SetT> >()
, add(*this)
{
}
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>::~symbols()
{}
template <typename T, typename CharT, typename SetT>
inline symbols<T, CharT, SetT>&
symbols<T, CharT, SetT>::operator=(symbols const& other)
{
    SetT::operator=(other);
    return *this;
}
template <typename T, typename CharT, typename SetT>
inline symbol_inserter<T, SetT> const&
symbols<T, CharT, SetT>::operator=(CharT const* str)
{
    return add, str;
}
template <typename T, typename CharT, typename SetT>
inline T*
find(symbols<T, CharT, SetT> const& table, CharT const* sym)
{
    CharT const* last = sym;
    while (*last)
        last++;
    scanner<CharT const *> scan(sym, last);
    T* result = table.find(scan);
    return scan.at_end()? result: 0;
}
template <typename T, typename CharT, typename SetT>
inline T*
add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data)
{
    CharT const* last = sym;
    while (*last)
        last++;
    scanner<CharT const *> scan(sym, last);
    if (table.find(scan))
        return 0;
    table.add(sym, last, data);
    return table.find(scan);
}
}}
using namespace boost::spirit;
using namespace std;
struct skip_grammar : public grammar<skip_grammar>
{
    template <typename ScannerT>
    struct definition
    {
        definition(skip_grammar const& )
        {
            skip
                = space_p
                | "//" >> *(anychar_p - '\n') >> '\n'
                | "/*" >> *(anychar_p - "*/") >> "*/"
                | "#line" >> *(anychar_p - '\n') >> '\n'
                | "#pragma" >> *(anychar_p - '\n') >> '\n'
                ;
        }
        rule<ScannerT> skip;
        rule<ScannerT> const&
        start() const { return skip; }
    };
};
template<typename GrammarT>
bool
parse(GrammarT const& g, char const* text, unsigned int len)
{
    skip_grammar skip;
    parse_info<const char *> result =
        parse(text, text+len, g, skip);
    return !!result.full;
}
struct c_grammar : public grammar<c_grammar>
{
    template <typename ScannerT>
    struct definition
    {
        definition(c_grammar const& ) :
            ELLIPSIS("..."), RIGHT_ASSIGN(">>="), LEFT_ASSIGN("<<="),
            ADD_ASSIGN("+="), SUB_ASSIGN("-="), MUL_ASSIGN("*="),
            DIV_ASSIGN("/="), MOD_ASSIGN("%="), AND_ASSIGN("&="),
            XOR_ASSIGN("^="), OR_ASSIGN("|="), RIGHT_OP(">>"), LEFT_OP("<<"),
            INC_OP("++"), DEC_OP("--"), PTR_OP("->"), AND_OP("&&"),
            OR_OP("||"), LE_OP("<="), GE_OP(">="), EQ_OP("=="), NE_OP("!="),
            SEMICOLON(';'),
            COMMA(','), COLON(':'), ASSIGN('='), LEFT_PAREN('('),
            RIGHT_PAREN(')'), DOT('.'), ADDROF('&'), BANG('!'), TILDE('~'),
            MINUS('-'), PLUS('+'), STAR('*'), SLASH('/'), PERCENT('%'),
            LT_OP('<'), GT_OP('>'), XOR('^'), OR('|'), QUEST('?')
        {
            keywords =
                "auto", "break", "case", "char", "const", "continue", "default",
                "do", "double", "else", "enum", "extern", "float", "for",
                "goto", "if", "int", "long", "register", "return", "short",
                "signed", "sizeof", "static", "struct", "switch", "typedef",
                "union", "unsigned", "void", "volatile", "while";
            LEFT_BRACE = chlit<>('{') | strlit<>("<%");
            RIGHT_BRACE = chlit<>('}') | strlit<>("%>");
            LEFT_BRACKET = chlit<>('[') | strlit<>("<:");
            RIGHT_BRACKET = chlit<>(']') | strlit<>(":>");
            AUTO = strlit<>("auto");
            BREAK = strlit<>("break");
            CASE = strlit<>("case");
            CHAR = strlit<>("char");
            CONST = strlit<>("const");
            CONTINUE = strlit<>("continue");
            DEFAULT = strlit<>("default");
            DO = strlit<>("do");
            DOUBLE = strlit<>("double");
            ELSE = strlit<>("else");
            ENUM = strlit<>("enum");
            EXTERN = strlit<>("extern");
            FOR = strlit<>("for");
            FLOAT = strlit<>("float");
            GOTO = strlit<>("goto");
            IF = strlit<>("if");
            INT = strlit<>("int");
            LONG = strlit<>("long");
            REGISTER = strlit<>("register");
            RETURN = strlit<>("return");
            SHORT = strlit<>("short");
            SIGNED = strlit<>("signed");
            SIZEOF = strlit<>("sizeof");
            STATIC = strlit<>("static");
            STRUCT = strlit<>("struct");
            SWITCH = strlit<>("switch");
            TYPEDEF = strlit<>("typedef");
            UNION = strlit<>("union");
            UNSIGNED = strlit<>("unsigned");
            VOID = strlit<>("void");
            VOLATILE = strlit<>("volatile");
            WHILE = strlit<>("while");
            IDENTIFIER =
                lexeme_d[
                    ((alpha_p | '_' | '$') >> *(alnum_p | '_' | '$'))
                    - (keywords >> anychar_p - (alnum_p | '_' | '$'))
                ]
                ;
            STRING_LITERAL_PART =
                lexeme_d[
                    !chlit<>('L') >> chlit<>('\"') >>
                    *( strlit<>("\\\"") | anychar_p - chlit<>('\"') ) >>
                    chlit<>('\"')
                ]
                ;
            STRING_LITERAL = +STRING_LITERAL_PART;
            INT_CONSTANT_HEX
                = lexeme_d[
                    chlit<>('0')
                    >> as_lower_d[chlit<>('x')]
                    >> +xdigit_p
                    >> !as_lower_d[chlit<>('l') | chlit<>('u')]
                ]
                ;
            INT_CONSTANT_OCT
                = lexeme_d[
                    chlit<>('0')
                    >> +range<>('0', '7')
                    >> !as_lower_d[chlit<>('l') | chlit<>('u')]
                ]
                ;
            INT_CONSTANT_DEC
                = lexeme_d[
                    +digit_p
                    >> !as_lower_d[chlit<>('l') | chlit<>('u')]
                ]
                ;
            INT_CONSTANT_CHAR
                = lexeme_d[
                    !chlit<>('L') >> chlit<>('\'') >>
                    longest_d[
                            anychar_p
                        | ( chlit<>('\\')
                                >> chlit<>('0')
                                >> repeat_p(0, 2)[range<>('0', '7')]
                            )
                        | (chlit<>('\\') >> anychar_p)
                    ] >>
                    chlit<>('\'')
                ]
                ;
            INT_CONSTANT =
                    INT_CONSTANT_HEX
                | INT_CONSTANT_OCT
                | INT_CONSTANT_DEC
                | INT_CONSTANT_CHAR
                ;
            FLOAT_CONSTANT_1
                = lexeme_d[
                    +digit_p
                    >> (chlit<>('e') | chlit<>('E'))
                    >> !(chlit<>('+') | chlit<>('-'))
                    >> +digit_p
                    >> !as_lower_d[chlit<>('l') | chlit<>('f')]
                ]
                ;
            FLOAT_CONSTANT_2
                = lexeme_d[
                    *digit_p
                    >> chlit<>('.')
                    >> +digit_p
                    >> !( (chlit<>('e') | chlit<>('E'))
                            >> !(chlit<>('+') | chlit<>('-'))
                            >> +digit_p
                        )
                    >> !as_lower_d[chlit<>('l') | chlit<>('f')]
                ]
                ;
            FLOAT_CONSTANT_3
                = lexeme_d[
                    +digit_p
                    >> chlit<>('.')
                    >> *digit_p
                    >> !( (chlit<>('e') | chlit<>('E'))
                            >> !(chlit<>('+') | chlit<>('-'))
                            >> +digit_p
                        )
                    >> !as_lower_d[chlit<>('l') | chlit<>('f')]
                ]
                ;
            FLOAT_CONSTANT =
                    FLOAT_CONSTANT_1
                | FLOAT_CONSTANT_2
                | FLOAT_CONSTANT_3
                ;
            CONSTANT = longest_d[FLOAT_CONSTANT | INT_CONSTANT];
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            ;
            primary_expression
                = IDENTIFIER
                | CONSTANT
                | STRING_LITERAL
                | LEFT_PAREN >> expression >> RIGHT_PAREN
                ;
            postfix_expression
                = primary_expression >> postfix_expression_helper
                ;
            postfix_expression_helper
                = (
                        LEFT_BRACKET >> expression >> RIGHT_BRACKET
                    | LEFT_PAREN >> !argument_expression_list >> RIGHT_PAREN
                    | DOT >> IDENTIFIER
                    | PTR_OP >> IDENTIFIER
                    | INC_OP
                    | DEC_OP
                    ) >>
                    postfix_expression_helper
                | epsilon_p
                ;
            argument_expression_list
                = assignment_expression >> *(COMMA >> assignment_expression)
                ;
            unary_expression
                = postfix_expression
                | INC_OP >> unary_expression
                | DEC_OP >> unary_expression
                | unary_operator >> cast_expression
                | SIZEOF >>
                    (
                        unary_expression
                    | LEFT_PAREN >> type_name >> RIGHT_PAREN
                    )
                ;
            unary_operator
                = ADDROF
                | STAR
                | PLUS
                | MINUS
                | TILDE
                | BANG
                ;
            cast_expression
                = LEFT_PAREN >> type_name >> RIGHT_PAREN >> cast_expression
                | unary_expression
                ;
            multiplicative_expression
                = cast_expression >> multiplicative_expression_helper
                ;
            multiplicative_expression_helper
                = (
                        STAR >> cast_expression
                    | SLASH >> cast_expression
                    | PERCENT >> cast_expression
                    ) >>
                    multiplicative_expression_helper
                | epsilon_p
                ;
            additive_expression
                = multiplicative_expression >> additive_expression_helper
                ;
            additive_expression_helper
                = (
                        PLUS >> multiplicative_expression
                    | MINUS >> multiplicative_expression
                    ) >>
                    additive_expression_helper
                | epsilon_p
                ;
            shift_expression
                = additive_expression >> shift_expression_helper
                ;
            shift_expression_helper
                = (
                        LEFT_OP >> additive_expression
                    | RIGHT_OP >> additive_expression
                    ) >>
                    shift_expression_helper
                | epsilon_p
                ;
            relational_expression
                = shift_expression >> relational_expression_helper
                ;
            relational_expression_helper
                = (
                        LT_OP >> shift_expression
                    | GT_OP >> shift_expression
                    | LE_OP >> shift_expression
                    | GE_OP >> shift_expression
                    ) >>
                    relational_expression_helper
                | epsilon_p
                ;
            equality_expression
                = relational_expression >> equality_expression_helper
                ;
            equality_expression_helper
                = (
                        EQ_OP >> relational_expression
                    | NE_OP >> relational_expression
                    ) >>
                    equality_expression_helper
                | epsilon_p
                ;
            and_expression
                = equality_expression >> and_expression_helper
                ;
            and_expression_helper
                = ADDROF >> equality_expression >> and_expression_helper
                | epsilon_p
                ;
            exclusive_or_expression
                = and_expression >> exclusive_or_expression_helper
                ;
            exclusive_or_expression_helper
                = XOR >> and_expression >> exclusive_or_expression_helper
                | epsilon_p
                ;
            inclusive_or_expression
                = exclusive_or_expression >> inclusive_or_expression_helper
                ;
            inclusive_or_expression_helper
                = OR >> exclusive_or_expression >> inclusive_or_expression_helper
                | epsilon_p
                ;
            logical_and_expression
                = inclusive_or_expression >> logical_and_expression_helper
                ;
            logical_and_expression_helper
                = AND_OP >> inclusive_or_expression >> logical_and_expression_helper
                | epsilon_p
                ;
            logical_or_expression
                = logical_and_expression >> logical_or_expression_helper
                ;
            logical_or_expression_helper
                = OR_OP >> logical_and_expression >> logical_or_expression_helper
                | epsilon_p
                ;
            conditional_expression
                = logical_or_expression >> conditional_expression_helper
                ;
            conditional_expression_helper
                = QUEST >> expression >> COLON
                    >> conditional_expression >> conditional_expression_helper
                | epsilon_p
                ;
            assignment_expression
                = unary_expression >> assignment_operator >> assignment_expression
                | conditional_expression
                ;
            assignment_operator
                = ASSIGN
                | MUL_ASSIGN
                | DIV_ASSIGN
                | MOD_ASSIGN
                | ADD_ASSIGN
                | SUB_ASSIGN
                | LEFT_ASSIGN
                | RIGHT_ASSIGN
                | AND_ASSIGN
                | XOR_ASSIGN
                | OR_ASSIGN
                ;
            expression
                = assignment_expression >> expression_helper
                ;
            expression_helper
                = COMMA >> assignment_expression >> expression_helper
                | epsilon_p
                ;
            constant_expression
                = conditional_expression
                ;
            declaration
                = declaration_specifiers >> !init_declarator_list >> SEMICOLON
                ;
            declaration_specifiers
                = (
                        storage_class_specifier
                    | type_specifier
                    | type_qualifier
                    ) >>
                    !declaration_specifiers
                ;
            init_declarator_list
                = init_declarator >> *(COMMA >> init_declarator)
                ;
            init_declarator
                = declarator >> !(ASSIGN >> initializer)
                ;
            storage_class_specifier
                = TYPEDEF
                | EXTERN
                | STATIC
                | AUTO
                | REGISTER
                ;
            type_specifier
                = VOID
                | CHAR
                | SHORT
                | INT
                | LONG
                | FLOAT
                | DOUBLE
                | SIGNED
                | UNSIGNED
                | struct_or_union_specifier
                | enum_specifier
                ;
            struct_or_union_specifier
                = struct_or_union >>
                    (
                        IDENTIFIER >> !(LEFT_BRACE >> struct_declaration_list
                            >> RIGHT_BRACE)
                    | LEFT_BRACE >> struct_declaration_list >> RIGHT_BRACE
                    )
                ;
            struct_or_union
                = STRUCT
                | UNION
                ;
            struct_declaration_list
                = +struct_declaration
                ;
            struct_declaration
                = specifier_qualifier_list >> struct_declarator_list >> SEMICOLON
                ;
            specifier_qualifier_list
                = (
                        type_specifier
                    | type_qualifier
                    ) >>
                    !specifier_qualifier_list
                ;
            struct_declarator_list
                = struct_declarator >> *(COMMA >> struct_declarator)
                ;
            struct_declarator
                = declarator || (COLON >> constant_expression)
                ;
            enum_specifier
                = ENUM >> !IDENTIFIER >> LEFT_BRACE >> enumerator_list >> RIGHT_BRACE
                ;
            enumerator_list
                = enumerator >> *(COMMA >> enumerator)
                ;
            enumerator
                = IDENTIFIER >> !(ASSIGN >> constant_expression)
                ;
            type_qualifier
                = CONST
                | VOLATILE
                ;
            declarator
                = !pointer >> direct_declarator
                ;
            direct_declarator
                = (
                        IDENTIFIER
                    | LEFT_PAREN >> declarator >> RIGHT_PAREN
                    ) >>
                    direct_declarator_helper
                ;
            direct_declarator_helper
                = (
                        LEFT_BRACKET >> !constant_expression >> RIGHT_BRACKET
                    | LEFT_PAREN >>
                    ! (
                            parameter_type_list
                        | identifier_list
                        ) >> RIGHT_PAREN
                    ) >> direct_declarator_helper
                | epsilon_p
                ;
            pointer
                = STAR >> !(type_qualifier_list || pointer)
                ;
            type_qualifier_list
                = +type_qualifier
                ;
            parameter_type_list
                = parameter_list >> !(COMMA >> ELLIPSIS)
                ;
            parameter_list
                = parameter_declaration >> *(COMMA >> parameter_declaration)
                ;
            parameter_declaration
                = declaration_specifiers >>
                   !(
                        declarator
                    | abstract_declarator
                    )
                ;
            identifier_list
                = IDENTIFIER >> *(COMMA >> IDENTIFIER)
                ;
            type_name
                = specifier_qualifier_list >> !abstract_declarator
                ;
            abstract_declarator
                = pointer || direct_abstract_declarator
                ;
            direct_abstract_declarator
                = (
                        LEFT_PAREN >>
                        (
                            abstract_declarator >> RIGHT_PAREN
                        | !parameter_type_list >> RIGHT_PAREN
                        )
                    | LEFT_BRACKET >> !constant_expression >> RIGHT_BRACKET
                    ) >>
                    direct_abstract_declarator_helper
                ;
            direct_abstract_declarator_helper
                = (
                        LEFT_BRACKET >> !constant_expression >> RIGHT_BRACKET
                    | LEFT_PAREN >> !parameter_type_list >> RIGHT_PAREN
                    ) >>
                    direct_abstract_declarator_helper
                | epsilon_p
                ;
            initializer
                = assignment_expression
                | LEFT_BRACE >> initializer_list >> !COMMA >> RIGHT_BRACE
                ;
            initializer_list
                = initializer >> *(COMMA >> initializer)
                ;
            statement
                = labeled_statement
                | compound_statement
                | expression_statement
                | selection_statement
                | iteration_statement
                | jump_statement
                ;
            labeled_statement
                = IDENTIFIER >> COLON >> statement
                | CASE >> constant_expression >> COLON >> statement
                | DEFAULT >> COLON >> statement
                ;
            compound_statement
                = LEFT_BRACE >> !(declaration_list || statement_list) >> RIGHT_BRACE
                ;
            declaration_list
                = +declaration
                ;
            statement_list
                = +statement
                ;
            expression_statement
                = !expression >> SEMICOLON
                ;
            selection_statement
                = IF >> LEFT_PAREN >> expression >> RIGHT_PAREN >> statement
                    >> !(ELSE >> statement)
                | SWITCH >> LEFT_PAREN >> expression >> RIGHT_PAREN >> statement
                ;
            iteration_statement
                = WHILE >> LEFT_PAREN >> expression >> RIGHT_PAREN >> statement
                | DO >> statement >> WHILE >> LEFT_PAREN >> expression
                    >> RIGHT_PAREN >> SEMICOLON
                | FOR >> LEFT_PAREN >> expression_statement >> expression_statement
                    >> !expression >> RIGHT_PAREN >> statement
                ;
            jump_statement
                = GOTO >> IDENTIFIER >> SEMICOLON
                | CONTINUE >> SEMICOLON
                | BREAK >> SEMICOLON
                | RETURN >> !expression >> SEMICOLON
                ;
            function_definition
                = !declaration_specifiers
                >> declarator
                >> !declaration_list
                >> compound_statement
                ;
            external_declaration
                = function_definition
                | declaration
                ;
            translation_unit
                = *external_declaration
                ;
        }
        symbols<> keywords;
        strlit<>
                ELLIPSIS, RIGHT_ASSIGN, LEFT_ASSIGN, ADD_ASSIGN, SUB_ASSIGN,
                MUL_ASSIGN, DIV_ASSIGN, MOD_ASSIGN, AND_ASSIGN, XOR_ASSIGN,
                OR_ASSIGN, RIGHT_OP, LEFT_OP, INC_OP, DEC_OP, PTR_OP, AND_OP,
                OR_OP, LE_OP, GE_OP, EQ_OP, NE_OP;
        chlit<>
                SEMICOLON, COMMA, COLON, ASSIGN, LEFT_PAREN, RIGHT_PAREN,
                DOT, ADDROF, BANG, TILDE, MINUS, PLUS, STAR, SLASH, PERCENT,
                LT_OP, GT_OP, XOR, OR, QUEST;
        rule<ScannerT>
                LEFT_BRACE, RIGHT_BRACE, LEFT_BRACKET, RIGHT_BRACKET;
        rule<ScannerT>
                AUTO, BREAK, CASE, CHAR, CONST, CONTINUE, DEFAULT, DO, DOUBLE,
                ELSE, ENUM, EXTERN, FOR, FLOAT, GOTO, IF, INT, LONG, REGISTER,
                RETURN, SHORT, SIGNED, SIZEOF, STATIC, STRUCT, SWITCH, TYPEDEF,
                UNION, UNSIGNED, VOID, VOLATILE, WHILE, IDENTIFIER,
                STRING_LITERAL_PART, STRING_LITERAL, INT_CONSTANT_HEX, INT_CONSTANT,
                INT_CONSTANT_OCT, INT_CONSTANT_DEC, INT_CONSTANT_CHAR,
                FLOAT_CONSTANT,FLOAT_CONSTANT_1, FLOAT_CONSTANT_2, FLOAT_CONSTANT_3,
                CONSTANT;
        rule<ScannerT>
                primary_expression, postfix_expression, postfix_expression_helper,
                argument_expression_list, unary_expression, unary_operator,
                cast_expression,
                multiplicative_expression, multiplicative_expression_helper,
                additive_expression, additive_expression_helper,
                shift_expression, shift_expression_helper,
                relational_expression, relational_expression_helper,
                equality_expression, equality_expression_helper,
                and_expression, and_expression_helper,
                exclusive_or_expression, exclusive_or_expression_helper,
                inclusive_or_expression, inclusive_or_expression_helper,
                logical_and_expression, logical_and_expression_helper,
                logical_or_expression, logical_or_expression_helper,
                conditional_expression, conditional_expression_helper,
                assignment_expression, assignment_operator,
                expression, expression_helper, constant_expression, declaration,
                declaration_specifiers, init_declarator_list, init_declarator,
                storage_class_specifier, type_specifier, struct_or_union_specifier,
                struct_or_union, struct_declaration_list, struct_declaration,
                specifier_qualifier_list, struct_declarator_list,
                struct_declarator, enum_specifier, enumerator_list, enumerator,
                type_qualifier, declarator,
                direct_declarator, direct_declarator_helper, pointer,
                type_qualifier_list, parameter_type_list, parameter_list,
                parameter_declaration, identifier_list, type_name,
                abstract_declarator,
                direct_abstract_declarator, direct_abstract_declarator_helper,
                initializer, initializer_list, statement, labeled_statement,
                compound_statement, declaration_list, statement_list,
                expression_statement, selection_statement, iteration_statement,
                jump_statement, translation_unit, external_declaration,
                function_definition;
        rule<ScannerT> const&
        start() const { return translation_unit; }
    };
};
extern const char *g_code;
int
main(int argc, char* argv[])
{
  c_grammar g;
  unsigned long n = 40;
  if (argc > 1)
    n = atol(argv[1]);
  for (unsigned long i=0;i<n;i++)
  {
    if (parse(g, g_code, strlen(g_code))) {
      std::cerr << "parse OK!\n";
    } else {
      std::cerr << "parse bad.\n";
    }
  }
  return 0;
}
const char *g_code =
" extern int debug_key_pressed; \n"
" void (*dsp32ops[])(void); \n"
"  \n"
"  \n"
"  \n"
"  \n"
"  \n"
"  \n"
"  \n"
" union int_double \n"
" { \n"
"         double d; \n"
"         unsigned long i[2]; \n"
" }; \n"
"  \n"
" static void illegal(void) \n"
" { \n"
" } \n"
"  \n"
"  \n"
" static void unimplemented(void) \n"
" { \n"
"         exit(1); \n"
" } \n"
"  \n"
"  \n"
"  void execute_one(void) \n"
" { \n"
"         if (dsp32.mbufaddr[++dsp32.mbuf_index & 3] != 1) { int bufidx = dsp32.mbuf_index & 3; if (dsp32.mbufaddr[bufidx] >= 0) WLONG(dsp32.mbufaddr[bufidx], dsp32.mbufdata[bufidx]); else WWORD(-dsp32.mbufaddr[bufidx], dsp32.mbufdata[bufidx]); dsp32.mbufaddr[bufidx] = 1; }; \n"
"         CALL_MAME_DEBUG; \n"
"         OP = ROPCODE(dsp32.PC); \n"
"         dsp32_icount -= 4; \n"
"         dsp32.PC += 4; \n"
"         if (OP) \n"
"                 (*dsp32ops[OP >> 21])(); \n"
" } \n"
"  \n"
" static unsigned long cau_read_pi_special(unsigned char i) \n"
" { \n"
"         switch (i) \n"
"         { \n"
"                 case 4: return dsp32.ibuf; \n"
"                 case 5: return dsp32.obuf; \n"
"                 case 6: update_pcr(dsp32.pcr & ~PCR_PDFs); return dsp32.pdr; \n"
"                 case 14: return dsp32.piop; \n"
"                 case 20: return dsp32.pdr2; \n"
"                 case 22: update_pcr(dsp32.pcr & ~PCR_PIFs); return dsp32.pir; \n"
"                 case 30: return dsp32.pcw; \n"
"         } \n"
"         return 0; \n"
" } \n"
"  \n"
"  \n"
" static void cau_write_pi_special(unsigned char i, unsigned long val) \n"
" { \n"
"         switch (i) \n"
"         { \n"
"                 case 4: dsp32.ibuf = val; break; \n"
"                 case 5: dsp32.obuf = val; break; \n"
"                 case 6: dsp32.pdr = val; update_pcr(dsp32.pcr | PCR_PDFs); break; \n"
"                 case 14: dsp32.piop = val; break; \n"
"                 case 20: dsp32.pdr2 = val; break; \n"
"                 case 22: dsp32.pir = val; update_pcr(dsp32.pcr | PCR_PIFs); break; \n"
"                 case 30: dsp32.pcw = val; break; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
"  unsigned char cau_read_pi_1byte(int pi) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RBYTE(dsp32.r[p]); \n"
"                 dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"                 return result; \n"
"         } \n"
"         else \n"
"                 return cau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  unsigned short cau_read_pi_2byte(int pi) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RWORD(dsp32.r[p]); \n"
"                 if (i < 22 || i > 23) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i] * 2) & 0xffffff); \n"
"                 return result; \n"
"         } \n"
"         else \n"
"                 return cau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  unsigned long cau_read_pi_4byte(int pi) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RLONG(dsp32.r[p]); \n"
"                 if (i < 22 || i > 23) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i] * 4) & 0xffffff); \n"
"                 return result; \n"
"         } \n"
"         else \n"
"                 return cau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  void cau_write_pi_1byte(int pi, unsigned char val) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 WBYTE(dsp32.r[p], val); \n"
"                 dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"         } \n"
"         else \n"
"                 cau_write_pi_special(i, val); \n"
" } \n"
"  \n"
"  \n"
"  void cau_write_pi_2byte(int pi, unsigned short val) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 WWORD(dsp32.r[p], val); \n"
"                 if (i < 22 || i > 23) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i] * 2) & 0xffffff); \n"
"         } \n"
"         else \n"
"                 cau_write_pi_special(i, val); \n"
" } \n"
"  \n"
"  \n"
"  void cau_write_pi_4byte(int pi, unsigned long val) \n"
" { \n"
"         int p = (pi >> 5) & 0x1f; \n"
"         int i = (pi >> 0) & 0x1f; \n"
"         if (p) \n"
"         { \n"
"                 WLONG(dsp32.r[p], (long)(val << 8) >> 8); \n"
"                 if (i < 22 || i > 23) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i] * 4) & 0xffffff); \n"
"         } \n"
"         else \n"
"                 cau_write_pi_special(i, val); \n"
" } \n"
"  double dau_get_amult(int aidx) \n"
" { \n"
"         int bufidx = (dsp32.abuf_index - 1) & 3; \n"
"         double val = dsp32.a[aidx]; \n"
"         while (dsp32_icount >= dsp32.abufcycle[bufidx] - 2 * 4) \n"
"         { \n"
"                 if (dsp32.abufreg[bufidx] == aidx) \n"
"                         val = dsp32.abuf[bufidx]; \n"
"                 bufidx = (bufidx - 1) & 3; \n"
"         } \n"
"         return val; \n"
" } \n"
"  \n"
"  \n"
"  double dau_get_anzflags(void) \n"
" { \n"
"         int bufidx = (dsp32.abuf_index - 1) & 3; \n"
"         double nzflags = dsp32.NZflags; \n"
"         while (dsp32_icount >= dsp32.abufcycle[bufidx] - 3 * 4) \n"
"         { \n"
"                 nzflags = dsp32.abufNZflags[bufidx]; \n"
"                 bufidx = (bufidx - 1) & 3; \n"
"         } \n"
"         return nzflags; \n"
" } \n"
"  \n"
"  \n"
"  unsigned char dau_get_avuflags(void) \n"
" { \n"
"  \n"
"         int bufidx = (dsp32.abuf_index - 1) & 3; \n"
"         unsigned char vuflags = dsp32.VUflags; \n"
"         while (dsp32_icount >= dsp32.abufcycle[bufidx] - 3 * 4) \n"
"         { \n"
"                 vuflags = dsp32.abufVUflags[bufidx]; \n"
"                 bufidx = (bufidx - 1) & 3; \n"
"         } \n"
"         return vuflags; \n"
"  \n"
"  \n"
"  \n"
" } \n"
"  \n"
"  \n"
"  void remember_last_dau(int aidx) \n"
" { \n"
"  \n"
"         int bufidx = dsp32.abuf_index++ & 3; \n"
"         dsp32.abuf[bufidx] = dsp32.a[aidx]; \n"
"         dsp32.abufreg[bufidx] = aidx; \n"
"         dsp32.abufNZflags[bufidx] = dsp32.NZflags; \n"
"  \n"
"         dsp32.abufVUflags[bufidx] = dsp32.VUflags; \n"
"  \n"
"         dsp32.abufcycle[bufidx] = dsp32_icount; \n"
"  \n"
" } \n"
"  \n"
"  \n"
"  void dau_set_val_noflags(int aidx, double res) \n"
" { \n"
"         remember_last_dau(aidx); \n"
"         dsp32.a[aidx] = res; \n"
" } \n"
"  \n"
"  \n"
"  void dau_set_val_flags(int aidx, double res) \n"
" { \n"
"         remember_last_dau(aidx); \n"
"  \n"
" { \n"
"         double absres = (res < 0) ? -res : res; \n"
"         dsp32.VUflags = 0; \n"
"         if (absres < 5.87747e-39) \n"
"         { \n"
"                 if (absres != 0) \n"
"                         dsp32.VUflags = UFLAGBIT; \n"
"                 res = 0.0; \n"
"         } \n"
"         else if (absres > 3.40282e38) \n"
"         { \n"
"                 dsp32.VUflags = VFLAGBIT; \n"
"  \n"
"  \n"
"                 res = (res < 0) ? -3.40282e38 : 3.40282e38; \n"
"         } \n"
" } \n"
"  \n"
"         dsp32.NZflags = res; \n"
"         dsp32.a[aidx] = res; \n"
" } \n"
"  \n"
"  \n"
" double dsp_to_double(unsigned long val) \n"
" { \n"
"         union int_double id; \n"
"  \n"
"         if (val == 0) \n"
"                 return 0; \n"
"         else if ((int)val > 0) \n"
"         { \n"
"                 int exponent = ((val & 0xff) - 128 + 1023) << 20; \n"
"                 id.i[BYTE_XOR_BE(0)] = exponent + (val >> 11); \n"
"                 id.i[BYTE_XOR_BE(1)] = (val << 21) & 0xe0000000; \n"
"         } \n"
"         else \n"
"         { \n"
"                 int exponent = ((val & 0xff) - 128 + 1023) << 20; \n"
"                 val = -(val & 0xffffff00); \n"
"                 id.i[BYTE_XOR_BE(0)] = 0x80000000 + exponent + ((val >> 11) & 0x001fffff); \n"
"                 id.i[BYTE_XOR_BE(1)] = (val << 21) & 0xe0000000; \n"
"         } \n"
"         return id.d; \n"
" } \n"
"  \n"
"  \n"
" unsigned long ddd(double val) \n"
" { \n"
"         int mantissa, exponent; \n"
"         union int_double id; \n"
"         id.d = val; \n"
"         mantissa = ((id.i[BYTE_XOR_BE(0)] & 0x000fffff) << 11) | ((id.i[BYTE_XOR_BE(1)] & 0xe0000000) >> 21); \n"
"         exponent = ((id.i[BYTE_XOR_BE(0)] & 0x7ff00000) >> 20) - 1023 + 128; \n"
"         if (exponent < 0) \n"
"                 return 0x00000000; \n"
"         else if (exponent > 255) \n"
"         { \n"
"  \n"
"  \n"
"                 return ((long)id.i[BYTE_XOR_BE(0)] >= 0) ? 0x7fffffff : 0x800000ff; \n"
"         } \n"
"         else if ((long)id.i[BYTE_XOR_BE(0)] >= 0) \n"
"                 return exponent | mantissa; \n"
"         else \n"
"         { \n"
"                 mantissa = -mantissa; \n"
"                 if (mantissa == 0) { mantissa = 0x80000000; exponent--; } \n"
"                 return 0x80000000 | exponent | (mantissa & 0xffffff00); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static double dau_read_pi_special(int i) \n"
" { \n"
"         exit(1); \n"
"         return 0; \n"
" } \n"
"  \n"
"  \n"
" static void dau_write_pi_special(int i, double val) \n"
" { \n"
"         exit(1); \n"
" } \n"
"  \n"
"  \n"
" static int lastp; \n"
"  \n"
"  double dau_read_pi_double_1st(int pi, int multiplier) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         lastp = p; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RLONG(dsp32.r[p]); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 4) & 0xffffff); \n"
"                 return dsp_to_double(result); \n"
"         } \n"
"         else if (i < 4) \n"
"                 return multiplier ? dau_get_amult(i) : dsp32.a[i]; \n"
"         else \n"
"                 return dau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  double dau_read_pi_double_2nd(int pi, int multiplier, double xval) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         if (p == 15) p = lastp; \n"
"         lastp = p; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result; \n"
"                 result = RLONG(dsp32.r[p]); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 4) & 0xffffff); \n"
"                 return dsp_to_double(result); \n"
"         } \n"
"         else if (i < 4) \n"
"                 return multiplier ? dau_get_amult(i) : dsp32.a[i]; \n"
"         else \n"
"                 return dau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  unsigned long dau_read_pi_4bytes(int pi) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         lastp = p; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RLONG(dsp32.r[p]); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 4) & 0xffffff); \n"
"                 return result; \n"
"         } \n"
"         else if (i < 4) \n"
"                 return double_to_dsp(dsp32.a[i]); \n"
"         else \n"
"                 return dau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  unsigned short dau_read_pi_2bytes(int pi) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         lastp = p; \n"
"         if (p) \n"
"         { \n"
"                 unsigned long result = RWORD(dsp32.r[p]); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 2) & 0xffffff); \n"
"                 return result; \n"
"         } \n"
"         else if (i < 4) \n"
"                 return double_to_dsp(dsp32.a[i]); \n"
"         else \n"
"                 return dau_read_pi_special(i); \n"
" } \n"
"  \n"
"  \n"
"  void dau_write_pi_double(int pi, double val) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         if (p == 15) p = lastp; \n"
"         if (p) \n"
"         { \n"
"                 do { int bufidx = dsp32.mbuf_index & 3; dsp32.mbufaddr[bufidx] = (dsp32.r[p]); dsp32.mbufdata[bufidx] = (double_to_dsp(val)); } while (0); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 4) & 0xffffff); \n"
"         } \n"
"         else if (i < 4) \n"
"                 dau_set_val_noflags(i, val); \n"
"         else \n"
"                 dau_write_pi_special(i, val); \n"
" } \n"
"  \n"
"  \n"
"  void dau_write_pi_4bytes(int pi, unsigned long val) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         if (p == 15) p = lastp; \n"
"         if (p) \n"
"         { \n"
"                 lastp = p; \n"
"                 do { int bufidx = dsp32.mbuf_index & 3; dsp32.mbufaddr[bufidx] = (dsp32.r[p]); dsp32.mbufdata[bufidx] = (val); } while (0); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 4) & 0xffffff); \n"
"         } \n"
"         else if (i < 4) \n"
"                 dau_set_val_noflags(i, dsp_to_double(val)); \n"
"         else \n"
"                 dau_write_pi_special(i, val); \n"
" } \n"
"  \n"
"  \n"
"  void dau_write_pi_2bytes(int pi, unsigned short val) \n"
" { \n"
"         int p = (pi >> 3) & 15; \n"
"         int i = (pi >> 0) & 7; \n"
"  \n"
"         if (p == 15) p = lastp; \n"
"         if (p) \n"
"         { \n"
"                 lastp = p; \n"
"                 do { int bufidx = dsp32.mbuf_index & 3; dsp32.mbufaddr[bufidx] = -(dsp32.r[p]); dsp32.mbufdata[bufidx] = (val); } while (0); \n"
"                 if (i < 6) \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16]) & 0xffffff); \n"
"                 else \n"
"                         dsp32.r[p] = ((dsp32.r[p] + dsp32.r[i+16] * 2) & 0xffffff); \n"
"         } \n"
"         else if (i < 4) \n"
"                 dau_set_val_noflags(i, dsp_to_double(val << 16)); \n"
"         else \n"
"                 dau_write_pi_special(i, val); \n"
" } \n"
" static int condition(int cond) \n"
" { \n"
"         switch (cond) \n"
"         { \n"
"                 case 0: \n"
"                         return 0; \n"
"                 case 1: \n"
"                         return 1; \n"
"                 case 2: \n"
"                         return !nFLAG; \n"
"                 case 3: \n"
"                         return nFLAG; \n"
"                 case 4: \n"
"                         return !zFLAG; \n"
"                 case 5: \n"
"                         return zFLAG; \n"
"                 case 6: \n"
"                         return !vFLAG; \n"
"                 case 7: \n"
"                         return vFLAG; \n"
"                 case 8: \n"
"                         return !cFLAG; \n"
"                 case 9: \n"
"                         return cFLAG; \n"
"                 case 10: \n"
"                         return !(nFLAG ^ cFLAG); \n"
"                 case 11: \n"
"                         return (nFLAG ^ cFLAG); \n"
"                 case 12: \n"
"                         return !(zFLAG | (nFLAG ^ vFLAG)); \n"
"                 case 13: \n"
"                         return (zFLAG | (nFLAG ^ vFLAG)); \n"
"                 case 14: \n"
"                         return !(cFLAG | zFLAG); \n"
"                 case 15: \n"
"                         return (cFLAG | zFLAG); \n"
"  \n"
"                 case 16: \n"
"                         return !(dau_get_avuflags() & UFLAGBIT); \n"
"                 case 17: \n"
"                         return (dau_get_avuflags() & UFLAGBIT); \n"
"                 case 18: \n"
"                         return !(dau_get_anzflags() < 0); \n"
"                 case 19: \n"
"                         return (dau_get_anzflags() < 0); \n"
"                 case 20: \n"
"                         return !(dau_get_anzflags() == 0); \n"
"                 case 21: \n"
"                         return (dau_get_anzflags() == 0); \n"
"                 case 22: \n"
"                         return !(dau_get_avuflags() & VFLAGBIT); \n"
"                 case 23: \n"
"                         return (dau_get_avuflags() & VFLAGBIT); \n"
"                 case 24: \n"
"                         return !(dau_get_anzflags() <= 0); \n"
"                 case 25: \n"
"                         return (dau_get_anzflags() <= 0); \n"
"  \n"
"                 case 32: \n"
"                 case 33: \n"
"                 case 34: \n"
"                 case 35: \n"
"                 case 36: \n"
"                 case 37: \n"
"                 case 38: \n"
"                 case 39: \n"
"                 case 40: \n"
"                 case 41: \n"
"                 case 42: \n"
"                 case 43: \n"
"                 case 44: \n"
"                 case 45: \n"
"                 case 46: \n"
"                 case 47: \n"
"                 default: \n"
"                         exit(1); \n"
"         } \n"
" } \n"
"  \n"
" static void nop(void) \n"
" { \n"
"         unsigned long op = 123; \n"
"         if (op == 0) \n"
"                 return; \n"
"         execute_one(); \n"
"         dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"         cpu_setopbase24ledw(dsp32.PC); \n"
"  \n"
" } \n"
"  \n"
" static void goto_t(void) \n"
" { \n"
"         unsigned long op = OP; \n"
"         execute_one(); \n"
"         dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"         cpu_setopbase24ledw(dsp32.PC); \n"
" } \n"
"  \n"
"  \n"
" static void goto_pl(void) \n"
" { \n"
"         if (!nFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_mi(void) \n"
" { \n"
"         if (nFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ne(void) \n"
" { \n"
"         if (!zFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_eq(void) \n"
" { \n"
"         if (zFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_vc(void) \n"
" { \n"
"         if (!vFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_vs(void) \n"
" { \n"
"         if (vFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_cc(void) \n"
" { \n"
"         if (!cFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_cs(void) \n"
" { \n"
"         if (cFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ge(void) \n"
" { \n"
"         if (!(nFLAG ^ vFLAG)) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_lt(void) \n"
" { \n"
"         if (nFLAG ^ vFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_gt(void) \n"
" { \n"
"         if (!(zFLAG | (nFLAG ^ vFLAG))) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_le(void) \n"
" { \n"
"         if (zFLAG | (nFLAG ^ vFLAG)) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_hi(void) \n"
" { \n"
"         if (!cFLAG && !zFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ls(void) \n"
" { \n"
"         if (cFLAG || zFLAG) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_auc(void) \n"
" { \n"
"         if (!(dau_get_avuflags() & UFLAGBIT)) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_aus(void) \n"
" { \n"
"         if (dau_get_avuflags() & UFLAGBIT) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_age(void) \n"
" { \n"
"         if (dau_get_anzflags() >= 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_alt(void) \n"
" { \n"
"         if (dau_get_anzflags() < 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ane(void) \n"
" { \n"
"         if (dau_get_anzflags() != 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_aeq(void) \n"
" { \n"
"         if (dau_get_anzflags() == 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_avc(void) \n"
" { \n"
"         if (!(dau_get_avuflags() & VFLAGBIT)) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_avs(void) \n"
" { \n"
"         if (dau_get_avuflags() & VFLAGBIT) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_agt(void) \n"
" { \n"
"         if (dau_get_anzflags() > 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ale(void) \n"
" { \n"
"         if (dau_get_anzflags() <= 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void goto_ibe(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_ibf(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_obf(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_obe(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_pde(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_pdf(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_pie(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_pif(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_syc(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_sys(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_fbc(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_fbs(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_irq1lo(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_irq1hi(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_irq2lo(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void goto_irq2hi(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void dec_goto(void) \n"
" { \n"
"         int hr = (OP >> 21) & 0x1f; \n"
"         int old = (short)dsp32.r[hr]; \n"
"         dsp32.r[hr] = (((long)(short)(dsp32.r[hr] - 1)) & 0xffffff); \n"
"         if (old >= 0) \n"
"         { \n"
"                 unsigned long op = OP; \n"
"                 execute_one(); \n"
"                 dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"                 cpu_setopbase24ledw(dsp32.PC); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void call(void) \n"
" { \n"
"         unsigned long op = OP; \n"
"         int mr = (op >> 21) & 0x1f; \n"
"         if (((0x6f3efffe) & (1 << (mr)))) \n"
"                 dsp32.r[mr] = dsp32.PC + 4; \n"
"         execute_one(); \n"
"         dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (short)op) & 0xffffff); \n"
"         cpu_setopbase24ledw(dsp32.PC); \n"
" } \n"
"  \n"
"  \n"
" static void goto24(void) \n"
" { \n"
"         unsigned long op = OP; \n"
"         execute_one(); \n"
"         dsp32.PC = (((dsp32.r[(op >> 16) & 0x1f]) + (op & 0xffff) + ((op >> 5) & 0xff0000)) & 0xffffff); \n"
"         cpu_setopbase24ledw(dsp32.PC); \n"
" } \n"
"  \n"
"  \n"
" static void call24(void) \n"
" { \n"
"         unsigned long op = OP; \n"
"         int mr = (op >> 16) & 0x1f; \n"
"         if (((0x6f3efffe) & (1 << (mr)))) \n"
"                 dsp32.r[mr] = dsp32.PC + 4; \n"
"         execute_one(); \n"
"         dsp32.PC = (op & 0xffff) + ((op >> 5) & 0xff0000); \n"
"         cpu_setopbase24ledw(dsp32.PC); \n"
" } \n"
"  \n"
"  \n"
" static void do_i(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void do_r(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
" static void add_si(void) \n"
" { \n"
"         int dr = (OP >> 21) & 0x1f; \n"
"         int hrval = ((unsigned short)dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = hrval + (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((hrval) ^ (OP) ^ (res) ^ ((res) >> 1)) << 8); \n"
" } \n"
"  \n"
"  \n"
" static void add_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval + s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void mul2_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = s1rval * 2; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((s1rval) ^ (0) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void subr_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s1rval - s2rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void addr_ss(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void sub_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval - s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void neg_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = -s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((s1rval) ^ (0) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void andc_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval & ~s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void cmp_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int drval = ((unsigned short)dsp32.r[(OP >> 16) & 0x1f]); \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = drval - s1rval; \n"
"                 dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((drval) ^ (s1rval) ^ (res) ^ ((res) >> 1)) << 8); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void xor_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval ^ s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void rcr_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = ((dsp32.nzcflags >> 9) & 0x8000) | (s1rval >> 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void or_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval | s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void rcl_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = ((dsp32.nzcflags >> 24) & 0x0001) | (s1rval << 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res & 0xffff) << 8) | ((s1rval & 0x8000) << 9); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void shr_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = s1rval >> 1; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void div2_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = (s1rval & 0x8000) | (s1rval >> 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = ((res & 0xffff) << 8) | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void and_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? ((unsigned short)dsp32.r[(OP >> 0) & 0x1f]) : ((unsigned short)dsp32.r[dr]); \n"
"                 int res = s2rval & s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void test_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int drval = ((unsigned short)dsp32.r[(OP >> 16) & 0x1f]); \n"
"                 int s1rval = ((unsigned short)dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = drval & s1rval; \n"
"                 dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void add_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval + (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((drval) ^ (OP) ^ (res) ^ ((res) >> 1)) << 8); \n"
" } \n"
"  \n"
"  \n"
" static void subr_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = (unsigned short)OP - drval; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((drval) ^ (OP) ^ (res) ^ ((res) >> 1)) << 8); \n"
" } \n"
"  \n"
"  \n"
" static void addr_di(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void sub_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval - (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((drval) ^ (OP) ^ (res) ^ ((res) >> 1)) << 8); \n"
" } \n"
"  \n"
"  \n"
" static void andc_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval & ~(unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void cmp_di(void) \n"
" { \n"
"         int drval = ((unsigned short)dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = drval - (unsigned short)OP; \n"
"         dsp32.nzcflags = ((res) << 8); dsp32.vflags = (((drval) ^ (OP) ^ (res) ^ ((res) >> 1)) << 8); \n"
" } \n"
"  \n"
"  \n"
" static void xor_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval ^ (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void or_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval | (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void and_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = ((unsigned short)dsp32.r[dr]); \n"
"         int res = drval & (unsigned short)OP; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void test_di(void) \n"
" { \n"
"         int drval = ((unsigned short)dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = drval & (unsigned short)OP; \n"
"         dsp32.nzcflags = (((res) << 8) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
" static void adde_si(void) \n"
" { \n"
"         int dr = (OP >> 21) & 0x1f; \n"
"         int hrval = (dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = hrval + (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = ((res) & 0xffffff); \n"
"         dsp32.nzcflags = (res); dsp32.vflags = ((hrval) ^ (OP << 8) ^ (res) ^ ((res) >> 1)); \n"
" } \n"
"  \n"
"  \n"
" static void adde_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval + s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void mul2e_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = s1rval * 2; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((s1rval) ^ (0) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void subre_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s1rval - s2rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void addre_ss(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void sube_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval - s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((s1rval) ^ (s2rval) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void nege_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = -s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((s1rval) ^ (0) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void andce_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval & ~s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void cmpe_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int drval = (dsp32.r[(OP >> 16) & 0x1f]); \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = drval - s1rval; \n"
"                 dsp32.nzcflags = (res); dsp32.vflags = ((drval) ^ (s1rval) ^ (res) ^ ((res) >> 1)); \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void xore_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval ^ s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void rcre_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = ((dsp32.nzcflags >> 1) & 0x800000) | (s1rval >> 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = res | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void ore_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval | s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void rcle_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = ((dsp32.nzcflags >> 24) & 0x000001) | (s1rval << 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = res | ((s1rval & 0x800000) << 1); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void shre_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = s1rval >> 1; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = res | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void div2e_s(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = (s1rval & 0x800000) | (s1rval >> 1); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = ((res) & 0xffffff); \n"
"                 dsp32.nzcflags = res | ((s1rval & 1) << 24); \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void ande_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int s2rval = (OP & 0x800) ? (dsp32.r[(OP >> 0) & 0x1f]) : (dsp32.r[dr]); \n"
"                 int res = s2rval & s1rval; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void teste_ss(void) \n"
" { \n"
"         if ((!(OP & 0x400) || (condition((OP >> 12) & 15)))) \n"
"         { \n"
"                 int drval = (dsp32.r[(OP >> 16) & 0x1f]); \n"
"                 int s1rval = (dsp32.r[(OP >> 5) & 0x1f]); \n"
"                 int res = drval & s1rval; \n"
"                 dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
"         } \n"
" } \n"
"  \n"
"  \n"
" static void adde_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval + (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = ((res) & 0xffffff); \n"
"         dsp32.nzcflags = (res); dsp32.vflags = ((drval) ^ (OP << 8) ^ (res) ^ ((res) >> 1)); \n"
" } \n"
"  \n"
"  \n"
" static void subre_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = (((long)(short)(OP)) & 0xffffff) - drval; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = ((res) & 0xffffff); \n"
"         dsp32.nzcflags = (res); dsp32.vflags = ((drval) ^ (OP << 8) ^ (res) ^ ((res) >> 1)); \n"
" } \n"
"  \n"
"  \n"
" static void addre_di(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void sube_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval - (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = ((res) & 0xffffff); \n"
"         dsp32.nzcflags = (res); dsp32.vflags = ((drval) ^ (OP << 8) ^ (res) ^ ((res) >> 1)); \n"
" } \n"
"  \n"
"  \n"
" static void andce_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval & ~(((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void cmpe_di(void) \n"
" { \n"
"         int drval = (dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = drval - (((long)(short)(OP)) & 0xffffff); \n"
"         dsp32.nzcflags = (res); dsp32.vflags = ((drval) ^ (OP << 8) ^ (res) ^ ((res) >> 1)); \n"
" } \n"
"  \n"
"  \n"
" static void xore_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval ^ (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void ore_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval | (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void ande_di(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         int drval = (dsp32.r[dr]); \n"
"         int res = drval & (((long)(short)(OP)) & 0xffffff); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void teste_di(void) \n"
" { \n"
"         int drval = (dsp32.r[(OP >> 16) & 0x1f]); \n"
"         int res = drval & (((long)(short)(OP)) & 0xffffff); \n"
"         dsp32.nzcflags = ((res) & 0xffffff); dsp32.vflags = 0; \n"
" } \n"
" static void load_hi(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         unsigned long res = RBYTE((((long)(short)(OP)) & 0xffffff)); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = res << 8; \n"
"         dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void load_li(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         unsigned long res = RBYTE((((long)(short)(OP)) & 0xffffff)); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = res << 8; \n"
"         dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void load_i(void) \n"
" { \n"
"         unsigned long res = RWORD((((long)(short)(OP)) & 0xffffff)); \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"         dsp32.nzcflags = res << 8; \n"
"         dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void load_ei(void) \n"
" { \n"
"         unsigned long res = ((RLONG((((long)(short)(OP)) & 0xffffff))) & 0xffffff); \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
"         dsp32.nzcflags = res; \n"
"         dsp32.vflags = 0; \n"
" } \n"
"  \n"
"  \n"
" static void store_hi(void) \n"
" { \n"
"         WBYTE((((long)(short)(OP)) & 0xffffff), dsp32.r[(OP >> 16) & 0x1f] >> 8); \n"
" } \n"
"  \n"
"  \n"
" static void store_li(void) \n"
" { \n"
"         WBYTE((((long)(short)(OP)) & 0xffffff), dsp32.r[(OP >> 16) & 0x1f]); \n"
" } \n"
"  \n"
"  \n"
" static void store_i(void) \n"
" { \n"
"         WWORD((((long)(short)(OP)) & 0xffffff), ((unsigned short)dsp32.r[(OP >> 16) & 0x1f])); \n"
" } \n"
"  \n"
"  \n"
" static void store_ei(void) \n"
" { \n"
"         WLONG((((long)(short)(OP)) & 0xffffff), (long)((dsp32.r[(OP >> 16) & 0x1f]) << 8) >> 8); \n"
" } \n"
"  \n"
"  \n"
" static void load_hr(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 unsigned long res = cau_read_pi_1byte(OP) << 8; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = res << 8; \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void load_lr(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"         { \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 unsigned long res = cau_read_pi_1byte(OP); \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = res << 8; \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void load_r(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"         { \n"
"                 unsigned long res = cau_read_pi_2byte(OP); \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = (((long)(short)(res)) & 0xffffff); \n"
"                 dsp32.nzcflags = res << 8; \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void load_er(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"         { \n"
"                 unsigned long res = ((cau_read_pi_4byte(OP)) & 0xffffff); \n"
"                 int dr = (OP >> 16) & 0x1f; \n"
"                 if (((0x6f3efffe) & (1 << (dr)))) \n"
"                         dsp32.r[dr] = res; \n"
"                 dsp32.nzcflags = res; \n"
"                 dsp32.vflags = 0; \n"
"         } \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void store_hr(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"                 cau_write_pi_1byte(OP, dsp32.r[(OP >> 16) & 0x1f] >> 8); \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void store_lr(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"                 cau_write_pi_1byte(OP, dsp32.r[(OP >> 16) & 0x1f]); \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void store_r(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"                 cau_write_pi_2byte(OP, ((unsigned short)dsp32.r[(OP >> 16) & 0x1f])); \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void store_er(void) \n"
" { \n"
"         if (!(OP & 0x400)) \n"
"                 cau_write_pi_4byte(OP, (dsp32.r[(OP >> 16) & 0x1f])); \n"
"         else \n"
"                 unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void load24(void) \n"
" { \n"
"         int dr = (OP >> 16) & 0x1f; \n"
"         unsigned long res = (OP & 0xffff) + ((OP >> 5) & 0xff0000); \n"
"         if (((0x6f3efffe) & (1 << (dr)))) \n"
"                 dsp32.r[dr] = res; \n"
" } \n"
" static void d1_aMpp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval + dau_get_amult((OP >> 26) & 7) * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMpm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval - dau_get_amult((OP >> 26) & 7) * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMmp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval + dau_get_amult((OP >> 26) & 7) * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMmm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval - dau_get_amult((OP >> 26) & 7) * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_0px(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
"         (void)xval; \n"
" } \n"
"  \n"
"  \n"
" static void d1_0mx(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
"         (void)xval; \n"
" } \n"
"  \n"
"  \n"
" static void d1_1pp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval + xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_1pm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval - xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_1mp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval + xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_1mm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval - xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMppr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMpmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMmpr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d1_aMmmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
" static void d2_aMpp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = dsp32.a[(OP >> 26) & 7] + yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMpm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = dsp32.a[(OP >> 26) & 7] - yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMmp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = -dsp32.a[(OP >> 26) & 7] + yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMmm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = -dsp32.a[(OP >> 26) & 7] - yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMppr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMpmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMmpr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d2_aMmmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
" static void d3_aMpp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = dsp32.a[(OP >> 26) & 7] + yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMpm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = dsp32.a[(OP >> 26) & 7] - yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMmp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = -dsp32.a[(OP >> 26) & 7] + yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMmm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 1, xval); \n"
"         double res = -dsp32.a[(OP >> 26) & 7] - yval * xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMppr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMpmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMmpr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d3_aMmmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
" static void d4_pp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval + xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d4_pm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = yval - xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d4_mp(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval + xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d4_mm(void) \n"
" { \n"
"         double xval = dau_read_pi_double_1st(OP >> 14, 1); \n"
"         double yval = dau_read_pi_double_2nd(OP >> 7, 0, xval); \n"
"         double res = -yval - xval; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, yval); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d4_ppr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d4_pmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d4_mpr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d4_mmr(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
" static void d5_ic(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d5_oc(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d5_float(void) \n"
" { \n"
"         double res = (double)(short)dau_read_pi_2bytes(OP >> 7); \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_int(void) \n"
" { \n"
"         double val = dau_read_pi_double_1st(OP >> 7, 0); \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         short res; \n"
"         if (!(dsp32.DAUC & 0x10)) val = floor(val + 0.5); \n"
"         else val = ceil(val - 0.5); \n"
"         res = (short)val; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_2bytes(zpi, res); \n"
"         dau_set_val_noflags((OP >> 21) & 3, dsp_to_double(res << 16)); \n"
" } \n"
"  \n"
"  \n"
" static void d5_round(void) \n"
" { \n"
"         double res = (double)(float)dau_read_pi_double_1st(OP >> 7, 0); \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_ifalt(void) \n"
" { \n"
"         int ar = (OP >> 21) & 3; \n"
"         double res = dsp32.a[ar]; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (NFLAG) \n"
"                 res = dau_read_pi_double_1st(OP >> 7, 0); \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_noflags(ar, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_ifaeq(void) \n"
" { \n"
"         int ar = (OP >> 21) & 3; \n"
"         double res = dsp32.a[ar]; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (ZFLAG) \n"
"                 res = dau_read_pi_double_1st(OP >> 7, 0); \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_noflags(ar, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_ifagt(void) \n"
" { \n"
"         int ar = (OP >> 21) & 3; \n"
"         double res = dsp32.a[ar]; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (!NFLAG && !ZFLAG) \n"
"                 res = dau_read_pi_double_1st(OP >> 7, 0); \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_noflags(ar, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_float24(void) \n"
" { \n"
"         double res = (double)((long)(dau_read_pi_4bytes(OP >> 7) << 8) >> 8); \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_double(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, res); \n"
" } \n"
"  \n"
"  \n"
" static void d5_int24(void) \n"
" { \n"
"         double val = dau_read_pi_double_1st(OP >> 7, 0); \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         long res; \n"
"         if (!(dsp32.DAUC & 0x10)) val = floor(val + 0.5); \n"
"         else val = ceil(val - 0.5); \n"
"         res = (long)val; \n"
"         if (res > 0x7fffff) res = 0x7fffff; \n"
"         else if (res < -0x800000) res = -0x800000; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_4bytes(zpi, (long)(res << 8) >> 8); \n"
"         dau_set_val_noflags((OP >> 21) & 3, dsp_to_double(res << 8)); \n"
" } \n"
"  \n"
"  \n"
" static void d5_ieee(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d5_dsp(void) \n"
" { \n"
"         unimplemented(); \n"
" } \n"
"  \n"
"  \n"
" static void d5_seed(void) \n"
" { \n"
"         unsigned long val = dau_read_pi_4bytes(OP >> 7); \n"
"         long res = val ^ 0x7fffffff; \n"
"         int zpi = (OP >> 0) & 0x7f; \n"
"         if (zpi != 7) \n"
"                 dau_write_pi_4bytes(zpi, res); \n"
"         dau_set_val_flags((OP >> 21) & 3, dsp_to_double((long)res)); \n"
" } \n"
" void (*dsp32ops[])(void) = \n"
" { \n"
"         nop, goto_t, goto_pl, goto_mi, goto_ne, goto_eq, goto_vc, goto_vs, \n"
"         goto_cc, goto_cs, goto_ge, goto_lt, goto_gt, goto_le, goto_hi, goto_ls, \n"
"         goto_auc, goto_aus, goto_age, goto_alt, goto_ane, goto_aeq, goto_avc, goto_avs, \n"
"         goto_agt, goto_ale, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         goto_ibe, goto_ibf, goto_obf, goto_obe, goto_pde, goto_pdf, goto_pie, goto_pif, \n"
"         goto_syc, goto_sys, goto_fbc, goto_fbs, goto_irq1lo,goto_irq1hi,goto_irq2lo,goto_irq2hi, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, \n"
"         dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, \n"
"         dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, \n"
"         dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, dec_goto, \n"
"  \n"
"         call, call, call, call, call, call, call, call, \n"
"         call, call, call, call, call, call, call, call, \n"
"         call, call, call, call, call, call, call, call, \n"
"         call, call, call, call, call, call, call, call, \n"
"         add_si, add_si, add_si, add_si, add_si, add_si, add_si, add_si, \n"
"         add_si, add_si, add_si, add_si, add_si, add_si, add_si, add_si, \n"
"         add_si, add_si, add_si, add_si, add_si, add_si, add_si, add_si, \n"
"         add_si, add_si, add_si, add_si, add_si, add_si, add_si, add_si, \n"
"  \n"
"         add_ss, mul2_s, subr_ss, addr_ss, sub_ss, neg_s, andc_ss, cmp_ss, \n"
"         xor_ss, rcr_s, or_ss, rcl_s, shr_s, div2_s, and_ss, test_ss, \n"
"         add_di, illegal, subr_di, addr_di, sub_di, illegal, andc_di, cmp_di, \n"
"         xor_di, illegal, or_di, illegal, illegal, illegal, and_di, test_di, \n"
"         load_hi, load_hi, load_li, load_li, load_i, load_i, load_ei, load_ei, \n"
"         store_hi, store_hi, store_li, store_li, store_i, store_i, store_ei, store_ei, \n"
"         load_hr, load_hr, load_lr, load_lr, load_r, load_r, load_er, load_er, \n"
"         store_hr, store_hr, store_lr, store_lr, store_r, store_r, store_er, store_er, \n"
"  \n"
"         d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpm, d1_aMpm, d1_aMpm, d1_aMpm, \n"
"         d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmm, d1_aMmm, d1_aMmm, d1_aMmm, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"         d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpm, d1_aMpm, d1_aMpm, d1_aMpm, \n"
"         d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmm, d1_aMmm, d1_aMmm, d1_aMmm, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"  \n"
"         d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpm, d1_aMpm, d1_aMpm, d1_aMpm, \n"
"         d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmm, d1_aMmm, d1_aMmm, d1_aMmm, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"         d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpp, d1_aMpm, d1_aMpm, d1_aMpm, d1_aMpm, \n"
"         d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmp, d1_aMmm, d1_aMmm, d1_aMmm, d1_aMmm, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"  \n"
"         d1_0px, d1_0px, d1_0px, d1_0px, d1_0px, d1_0px, d1_0px, d1_0px, \n"
"         d1_0mx, d1_0mx, d1_0mx, d1_0mx, d1_0mx, d1_0mx, d1_0mx, d1_0mx, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"         d1_1pp, d1_1pp, d1_1pp, d1_1pp, d1_1pm, d1_1pm, d1_1pm, d1_1pm, \n"
"         d1_1mp, d1_1mp, d1_1mp, d1_1mp, d1_1mm, d1_1mm, d1_1mm, d1_1mm, \n"
"         d1_aMppr, d1_aMppr, d1_aMppr, d1_aMppr, d1_aMpmr, d1_aMpmr, d1_aMpmr, d1_aMpmr, \n"
"         d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmpr, d1_aMmmr, d1_aMmmr, d1_aMmmr, d1_aMmmr, \n"
"  \n"
"         d4_pp, d4_pp, d4_pp, d4_pp, d4_pm, d4_pm, d4_pm, d4_pm, \n"
"         d4_mp, d4_mp, d4_mp, d4_mp, d4_mm, d4_mm, d4_mm, d4_mm, \n"
"         d4_ppr, d4_ppr, d4_ppr, d4_ppr, d4_pmr, d4_pmr, d4_pmr, d4_pmr, \n"
"         d4_mpr, d4_mpr, d4_mpr, d4_mpr, d4_mmr, d4_mmr, d4_mmr, d4_mmr, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"  \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"  \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"         d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpp, d2_aMpm, d2_aMpm, d2_aMpm, d2_aMpm, \n"
"         d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmp, d2_aMmm, d2_aMmm, d2_aMmm, d2_aMmm, \n"
"         d2_aMppr, d2_aMppr, d2_aMppr, d2_aMppr, d2_aMpmr, d2_aMpmr, d2_aMpmr, d2_aMpmr, \n"
"         d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmpr, d2_aMmmr, d2_aMmmr, d2_aMmmr, d2_aMmmr, \n"
"  \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"  \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"  \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"         d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpp, d3_aMpm, d3_aMpm, d3_aMpm, d3_aMpm, \n"
"         d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmp, d3_aMmm, d3_aMmm, d3_aMmm, d3_aMmm, \n"
"         d3_aMppr, d3_aMppr, d3_aMppr, d3_aMppr, d3_aMpmr, d3_aMpmr, d3_aMpmr, d3_aMpmr, \n"
"         d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmpr, d3_aMmmr, d3_aMmmr, d3_aMmmr, d3_aMmmr, \n"
"  \n"
"         d5_ic, d5_ic, d5_ic, d5_ic, d5_oc, d5_oc, d5_oc, d5_oc, \n"
"         d5_float, d5_float, d5_float, d5_float, d5_int, d5_int, d5_int, d5_int, \n"
"         d5_round, d5_round, d5_round, d5_round, d5_ifalt, d5_ifalt, d5_ifalt, d5_ifalt, \n"
"         d5_ifaeq, d5_ifaeq, d5_ifaeq, d5_ifaeq, d5_ifagt, d5_ifagt, d5_ifagt, d5_ifagt, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         d5_float24, d5_float24, d5_float24, d5_float24, d5_int24, d5_int24, d5_int24, d5_int24, \n"
"         d5_ieee, d5_ieee, d5_ieee, d5_ieee, d5_dsp, d5_dsp, d5_dsp, d5_dsp, \n"
"         d5_seed, d5_seed, d5_seed, d5_seed, illegal, illegal, illegal, illegal, \n"
"  \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         do_i, do_r, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, \n"
"         adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, \n"
"         adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, \n"
"         adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, adde_si, \n"
"  \n"
"         adde_ss, mul2e_s, subre_ss, addre_ss, sube_ss, nege_s, andce_ss, cmpe_ss, \n"
"         xore_ss, rcre_s, ore_ss, rcle_s, shre_s, div2e_s, ande_ss, teste_ss, \n"
"         adde_di, illegal, subre_di, addre_di, sube_di, illegal, andce_di, cmpe_di, \n"
"         xore_di, illegal, ore_di, illegal, illegal, illegal, ande_di, teste_di, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"         illegal, illegal, illegal, illegal, illegal, illegal, illegal, illegal, \n"
"  \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"  \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"  \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"  \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"         goto24, goto24, goto24, goto24, goto24, goto24, goto24, goto24, \n"
"  \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"  \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"  \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"  \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"         load24, load24, load24, load24, load24, load24, load24, load24, \n"
"  \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"  \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"  \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"  \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24, \n"
"         call24, call24, call24, call24, call24, call24, call24, call24 \n"
" }; \n";